@loaders.gl/polyfills 4.0.0-beta.2 → 4.0.0-beta.4

package/src/index.ts

@@ -1,20 +1,29 @@
 /* eslint-disable dot-notation */
-import {isBrowser} from './utils/globals';
+import {isBrowser} from './utils/is-browser';
 
-import {TextDecoder, TextEncoder} from './lib/encoding';
-import {allSettled} from './promise/all-settled';
+import {TextDecoder, TextEncoder} from './text-encoder/text-encoder';
 
 // Node specific
-import * as base64 from './node/buffer/btoa.node';
+import {atob, btoa} from './buffer/btoa.node';
 
-import {encodeImageNode} from './node/images/encode-image.node';
-import {parseImageNode, NODE_FORMAT_SUPPORT} from './node/images/parse-image.node';
+import {encodeImageNode} from './images/encode-image-node';
+import {parseImageNode, NODE_FORMAT_SUPPORT} from './images/parse-image-node';
 
-// export {ReadableStreamPolyfill} from './node/file/readable-stream';
-// export {BlobPolyfill} from './node/file/blob';
-export {FileReaderPolyfill} from './node/file/file-reader';
-export {FilePolyfill} from './node/file/file';
-export {installFilePolyfills} from './node/file/install-file-polyfills';
+// FILESYSTEM POLYFILLS
+import {NodeFile} from './filesystems/node-file';
+import {NodeFileSystem} from './filesystems/node-filesystem';
+import {fetchNode} from './filesystems/fetch-node';
+
+// NODE VERSION
+import {versions} from 'node:process';
+export const nodeVersion = parseInt(versions.node.split('.')[0]);
+
+// STREAM POLYFILLS
+import {makeNodeStream} from './streams/make-node-stream';
+
+// BLOB AND FILE POLYFILLS
+export {Blob_ as Blob} from './file/install-blob-polyfills';
+export {File_ as File} from './file/install-file-polyfills';
 
 if (isBrowser) {
   // eslint-disable-next-line no-console
@@ -23,6 +32,17 @@ if (isBrowser) {
   );
 }
 
+globalThis.loaders = globalThis.loaders || {};
+
+// STREAM POLYFILLS
+export {makeNodeStream} from './streams/make-node-stream';
+globalThis.loaders.makeNodeStream = makeNodeStream;
+
+// FILESYSTEM POLYFILLS
+globalThis.loaders.NodeFile = NodeFile;
+globalThis.loaders.NodeFileSystem = NodeFileSystem;
+globalThis.loaders.fetchNode = fetchNode;
+
 // POLYFILLS: TextEncoder, TextDecoder
 // - Recent Node versions have these classes but virtually no encodings unless special build.
 // - Browser: Edge, IE11 do not have these
@@ -41,58 +61,61 @@ if (!globalThis.TextDecoder) {
 // - Node: Yes
 // - Browser: No
 
-if (!isBrowser && !('atob' in globalThis) && base64.atob) {
-  globalThis['atob'] = base64.atob;
+if (!('atob' in globalThis) && atob) {
+  globalThis['atob'] = atob;
 }
-if (!isBrowser && !('btoa' in globalThis) && base64.btoa) {
-  globalThis['btoa'] = base64.btoa;
+if (!('btoa' in globalThis) && btoa) {
+  globalThis['btoa'] = btoa;
 }
 
-globalThis.loaders = globalThis.loaders || {};
-
-// FILESYSTEM POLYFILLS:
-export {NodeFileSystem} from './filesystems/node-filesystem';
-import {NodeFileSystem} from './filesystems/node-filesystem';
-globalThis.loaders.NodeFileSystem = NodeFileSystem;
-
 // NODE IMAGE FUNCTIONS:
 // These are not official polyfills but used by the @loaders.gl/images module if installed
 // TODO - is there an appropriate Image API we could polyfill using an adapter?
 
-if (!isBrowser && !('_encodeImageNode' in globalThis) && encodeImageNode) {
-  globalThis['_encodeImageNode'] = encodeImageNode;
-}
+globalThis.loaders.encodeImageNode = encodeImageNode;
+globalThis.loaders.parseImageNode = parseImageNode;
+globalThis.loaders.imageFormatsNode = NODE_FORMAT_SUPPORT;
 
-if (!isBrowser && !('_parseImageNode' in globalThis) && parseImageNode) {
-  globalThis['_parseImageNode'] = parseImageNode;
-  globalThis['_imageFormatsNode'] = NODE_FORMAT_SUPPORT;
-}
+// Deprecated, remove after republish
+globalThis._parseImageNode = parseImageNode;
+globalThis._imageFormatsNode = NODE_FORMAT_SUPPORT;
 
-if (!('allSettled' in Promise)) {
-  // @ts-ignore
-  Promise.allSettled = allSettled;
-}
+// LOAD LIBRARY
+
+import {
+  readFileAsArrayBuffer,
+  readFileAsText,
+  requireFromFile,
+  requireFromString
+} from './load-library/require-utils.node';
+
+globalThis.loaders.readFileAsArrayBuffer = readFileAsArrayBuffer;
+globalThis.loaders.readFileAsText = readFileAsText;
+globalThis.loaders.requireFromFile = requireFromFile;
+globalThis.loaders.requireFromString = requireFromString;
 
 // DEPRECATED POLYFILL:
 // - Node v18+: No, not needed
 // - Node v16 and lower: Yes
 // - Browsers (evergreen): Not needed.
 // - IE11: No. This polyfill is node only, install external polyfill
-import {Headers as HeadersNode} from './node/fetch/headers.node';
-import {Response as ResponseNode} from './node/fetch/response.node';
-import {fetchNode as fetchNode} from './node/fetch/fetch.node';
-
-if (!isBrowser && !('Headers' in globalThis) && HeadersNode) {
-  // @ts-expect-error
-  globalThis.Headers = HeadersNode;
-}
-
-if (!isBrowser && !('Response' in globalThis) && ResponseNode) {
-  // @ts-expect-error
-  globalThis.Response = ResponseNode;
-}
-
-if (!isBrowser && !('fetch' in globalThis) && fetchNode) {
-  // @ts-expect-error
-  globalThis.fetch = fetchNode;
+import {Headers as HeadersNode} from './fetch/headers-polyfill';
+import {Response as ResponseNode} from './fetch/response-polyfill';
+import {fetchNode as fetchNodePolyfill} from './fetch/fetch-polyfill';
+
+if (nodeVersion < 18) {
+  if (!('Headers' in globalThis) && HeadersNode) {
+    // @ts-ignore
+    globalThis.Headers = HeadersNode;
+  }
+
+  if (!('Response' in globalThis) && ResponseNode) {
+    // @ts-ignore
+    globalThis.Response = ResponseNode;
+  }
+
+  if (!('fetch' in globalThis) && fetchNodePolyfill) {
+    // @ts-ignore
+    globalThis.fetch = fetchNodePolyfill;
+  }
 }

package/src/load-library/require-utils.node.ts

@@ -0,0 +1,101 @@
+// Fork of https://github.com/floatdrop/require-from-string/blob/master/index.js
+// Copyright (c) Vsevolod Strukchinsky <floatdrop@gmail.com> (github.com/floatdrop)
+// MIT license
+
+// this file is not visible to webpack (it is excluded in the package.json "browser" field).
+
+import Module from 'module';
+import path from 'path';
+import fs from 'fs';
+
+/**
+ * Load a file from local file system
+ * @param filename
+ * @returns
+ */
+export async function readFileAsArrayBuffer(filename: string): Promise<ArrayBuffer> {
+  if (filename.startsWith('http')) {
+    const response = await fetch(filename);
+    return await response.arrayBuffer();
+  }
+  const buffer = fs.readFileSync(filename);
+  return buffer.buffer;
+}
+
+/**
+ * Load a file from local file system
+ * @param filename
+ * @returns
+ */
+export async function readFileAsText(filename: string): Promise<string> {
+  if (filename.startsWith('http')) {
+    const response = await fetch(filename);
+    return await response.text();
+  }
+  const text = fs.readFileSync(filename, 'utf8');
+  return text;
+}
+
+// Node.js Dynamically require from file
+// Relative names are resolved relative to cwd
+// This indirect function is provided because webpack will try to bundle `module.require`.
+// this file is not visible to webpack (it is excluded in the package.json "browser" field).
+export async function requireFromFile(filename: string): Promise<any> {
+  if (filename.startsWith('http')) {
+    const response = await fetch(filename);
+    const code = await response.text();
+    return requireFromString(code);
+  }
+
+  if (!filename.startsWith('/')) {
+    filename = `${process.cwd()}/${filename}`;
+  }
+  const code = await fs.readFileSync(filename, 'utf8');
+  return requireFromString(code);
+}
+
+// Dynamically require from string
+// - `code` - Required - Type: string - Module code.
+// - `filename` - Type: string - Default: '' - Optional filename.
+// - `options.appendPaths` Type: Array List of paths, that will be appended to module paths.
+// Useful, when you want to be able require modules from these paths.
+// - `options.prependPaths` Type: Array Same as appendPaths, but paths will be prepended.
+export function requireFromString(
+  code: string,
+  filename = '',
+  options?: {
+    prependPaths?: string[];
+    appendPaths?: string[];
+  }
+): any {
+  if (typeof filename === 'object') {
+    options = filename;
+    filename = '';
+  }
+  filename = filename.replace('file://', '');
+
+  if (typeof code !== 'string') {
+    throw new Error(`code must be a string, not ${typeof code}`);
+  }
+
+  // @ts-ignore
+  const paths = Module._nodeModulePaths(path.dirname(filename));
+
+  const parent = typeof module !== 'undefined' && module?.parent;
+
+  // @ts-ignore
+  const newModule = new Module(filename, parent);
+  newModule.filename = filename;
+  newModule.paths = ([] as string[])
+    .concat(options?.prependPaths || [])
+    .concat(paths)
+    .concat(options?.appendPaths || []);
+  // @ts-ignore
+  newModule._compile(code, filename);
+
+  if (parent && parent.children) {
+    parent.children.splice(parent.children.indexOf(newModule), 1);
+  }
+
+  return newModule.exports;
+}

package/src/streams/make-node-stream.ts

@@ -0,0 +1,74 @@
+import type {ReadableOptions} from 'stream';
+import * as Stream from 'stream';
+
+class _Readable {}
+
+type ReadableType = Stream.Readable | _Readable;
+const Readable = Stream.Readable || _Readable;
+
+export type MakeStreamOptions = ReadableOptions;
+
+/** Builds a node stream from an iterator */
+export function makeNodeStream<ArrayBuffer>(
+  source: Iterable<ArrayBuffer> | AsyncIterable<ArrayBuffer>,
+  options?: ReadableOptions
+): ReadableType {
+  // @ts-ignore AsyncGenerator
+  const iterator = source[Symbol.asyncIterator]
+    ? // @ts-ignore AsyncGenerator
+      source[Symbol.asyncIterator]()
+    : // @ts-ignore AsyncGenerator
+      source[Symbol.iterator]();
+  return new AsyncIterableReadable(iterator, options);
+}
+
+class AsyncIterableReadable extends Readable {
+  private _pulling: boolean;
+  private _bytesMode: boolean;
+  private _iterator: AsyncIterator<ArrayBuffer>;
+
+  constructor(it: AsyncIterator<ArrayBuffer>, options?: ReadableOptions) {
+    super(options);
+    this._iterator = it;
+    this._pulling = false;
+    this._bytesMode = !options || !options.objectMode;
+  }
+
+  async _read(size: number): Promise<void> {
+    if (!this._pulling) {
+      this._pulling = true;
+      this._pulling = await this._pull(size, this._iterator);
+    }
+  }
+
+  async _destroy(error: Error | null, cb: (e: Error | null) => void): Promise<void> {
+    if (!this._iterator) {
+      return;
+    }
+    if (error) {
+      await this._iterator?.throw?.(error);
+    } else {
+      await this._iterator?.return?.(error);
+    }
+    cb?.(null);
+  }
+
+  // eslint-disable-next-line complexity
+  private async _pull(size: number, it: AsyncIterator<ArrayBuffer>): Promise<boolean> {
+    const bm = this._bytesMode;
+    let r: IteratorResult<ArrayBuffer> | null = null;
+    // while (this.readable && !(r = await it.next(bm ? size : null)).done) {
+    while (this.readable && !(r = await it.next()).done) {
+      if (size !== null) {
+        size -= bm && ArrayBuffer.isView(r.value) ? r.value.byteLength : 1;
+      }
+      if (!this.push(new Uint8Array(r.value)) || size <= 0) {
+        break;
+      }
+    }
+    if ((r?.done || !this.readable) && (this.push(null) || true)) {
+      it?.return?.();
+    }
+    return !this.readable;
+  }
+}

package/src/{lib/encoding.ts → text-encoder/text-encoder.ts}

@@ -8,7 +8,7 @@
 import indexes from './encoding-indexes';
 // Note: Aaian character indices add half a megabyte to bundle. Ignore, since we really only want the built-in UTF8...
 // import indexes from './encoding-indexes-asian.js';
-global['encoding-indexes'] = indexes || {};
+globalThis['encoding-indexes'] = indexes || {};
 
 //
 // Utilities
@@ -720,10 +720,10 @@ function indexPointerFor(code_point, index) {
  * @return {(!Array.<number>|!Array.<Array.<number>>)}
  *  */
 function index(name) {
-  if (!('encoding-indexes' in global)) {
+  if (!('encoding-indexes' in globalThis)) {
     throw Error('Indexes missing.' + ' Did you forget to include encoding-indexes.js first?');
   }
-  return global['encoding-indexes'][name];
+  return globalThis['encoding-indexes'][name];
 }
 
 /**
@@ -1121,7 +1121,7 @@ function TextEncoder(label, options) {
     // Standard behavior.
     enc._encoding = getEncoding('utf-8');
 
-    if (label !== undefined && 'console' in global) {
+    if (label !== undefined && 'console' in globalThis) {
       console.warn('TextEncoder constructor called with encoding label, ' + 'which is ignored.');
     }
   }
@@ -1483,7 +1483,7 @@ function SingleByteEncoder(index, options) {
 }
 
 (function () {
-  if (!('encoding-indexes' in global)) return;
+  if (!('encoding-indexes' in globalThis)) return;
   encodings.forEach(function (category) {
     if (category.heading !== 'Legacy single-byte encodings') return;
     category.encodings.forEach(function (encoding) {
@@ -3077,8 +3077,8 @@ decoders['x-user-defined'] = function (options) {
 };
 
 // FORK
-// if (!global['TextEncoder']) global['TextEncoder'] = TextEncoder;
-// if (!global['TextDecoder']) global['TextDecoder'] = TextDecoder;
+// if (!globalThis['TextEncoder']) globalThis['TextEncoder'] = TextEncoder;
+// if (!globalThis['TextDecoder']) globalThis['TextDecoder'] = TextDecoder;
 // babel.config.js skip transpiling files in `libs/`
 // module.exports = {TextEncoder, TextDecoder};
 export {TextEncoder, TextDecoder};

package/src/utils/is-browser.ts

@@ -0,0 +1,6 @@
+// loaders.gl, MIT license
+
+/* eslint-disable no-restricted-globals */
+export const isBrowser: boolean =
+  // @ts-ignore process.browser
+  typeof process !== 'object' || String(process) !== '[object process]' || process.browser;

package/dist/bundle.d.ts

@@ -1,2 +0,0 @@
-declare const moduleExports: any;
-//# sourceMappingURL=bundle.d.ts.map

package/dist/bundle.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bundle.d.ts","sourceRoot":"","sources":["../src/bundle.ts"],"names":[],"mappings":"AACA,QAAA,MAAM,aAAa,KAAqB,CAAC"}

package/dist/dist.min.js

@@ -1,63 +0,0 @@
-(() => {
-  var __defProp = Object.defineProperty;
-  var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
-  var __esm = (fn, res) => function __init() {
-    return fn && (res = (0, fn[Object.keys(fn)[0]])(fn = 0)), res;
-  };
-  var __commonJS = (cb, mod) => function __require() {
-    return mod || (0, cb[Object.keys(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-  };
-  var __export = (target, all) => {
-    __markAsModule(target);
-    for (var name in all)
-      __defProp(target, name, { get: all[name], enumerable: true });
-  };
-
-  // src/promise/all-settled.ts
-  function allSettled(promises) {
-    const mappedPromises = promises.map((promise) => {
-      return promise.then((value) => {
-        return { status: FULFILLED_STATUS, value };
-      }).catch((reason) => {
-        return { status: REJECTED_STATUS, reason };
-      });
-    });
-    return Promise.all(mappedPromises);
-  }
-  var REJECTED_STATUS, FULFILLED_STATUS;
-  var init_all_settled = __esm({
-    "src/promise/all-settled.ts"() {
-      REJECTED_STATUS = "rejected";
-      FULFILLED_STATUS = "fulfilled";
-    }
-  });
-
-  // src/index.browser.ts
-  var index_browser_exports = {};
-  __export(index_browser_exports, {
-    NodeFileSystem: () => NodeFileSystem,
-    installFilePolyfills: () => installFilePolyfills
-  });
-  function installFilePolyfills() {
-  }
-  var NodeFileSystem;
-  var init_index_browser = __esm({
-    "src/index.browser.ts"() {
-      init_all_settled();
-      if (!("allSettled" in Promise)) {
-        Promise.allSettled = allSettled;
-      }
-      NodeFileSystem = null;
-    }
-  });
-
-  // src/bundle.ts
-  var require_bundle = __commonJS({
-    "src/bundle.ts"(exports, module) {
-      var moduleExports = (init_index_browser(), index_browser_exports);
-      globalThis.loaders = globalThis.loaders || {};
-      module.exports = Object.assign(globalThis.loaders, moduleExports);
-    }
-  });
-  require_bundle();
-})();

package/dist/es5/bundle.js

@@ -1,6 +0,0 @@
-"use strict";
-
-var moduleExports = require('./index');
-globalThis.loaders = globalThis.loaders || {};
-module.exports = Object.assign(globalThis.loaders, moduleExports);
-//# sourceMappingURL=bundle.js.map

package/dist/es5/bundle.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"bundle.js","names":["moduleExports","require","globalThis","loaders","module","exports","Object","assign"],"sources":["../../src/bundle.ts"],"sourcesContent":["// @ts-nocheck\nconst moduleExports = require('./index');\nglobalThis.loaders = globalThis.loaders || {};\nmodule.exports = Object.assign(globalThis.loaders, moduleExports);\n"],"mappings":";;AACA,IAAMA,aAAa,GAAGC,OAAO,CAAC,SAAS,CAAC;AACxCC,UAAU,CAACC,OAAO,GAAGD,UAAU,CAACC,OAAO,IAAI,CAAC,CAAC;AAC7CC,MAAM,CAACC,OAAO,GAAGC,MAAM,CAACC,MAAM,CAACL,UAAU,CAACC,OAAO,EAAEH,aAAa,CAAC"}