@loaders.gl/loader-utils 3.1.0-alpha.1 → 3.1.0-alpha.5

package/dist/lib/node/util.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+import * as util from 'util';
+/** Wrapper for Node.js promisify */
+export declare const promisify: typeof util.promisify;

package/dist/lib/parser-utils/parse-json.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Minimal JSON parser that throws more meaningful error messages
+ */
+export declare function parseJSON(string: string): any;

package/dist/lib/path-utils/file-aliases.d.ts

@@ -0,0 +1,16 @@
+export declare function setPathPrefix(prefix: string): void;
+export declare function getPathPrefix(): string;
+/**
+ *
+ * @param aliases
+ *
+ * Note: addAliases are an experimental export, they are only for testing of loaders.gl loaders
+ * not intended as a generic aliasing mechanism
+ */
+export declare function addAliases(aliases: {
+    [aliasPath: string]: string;
+}): void;
+/**
+ * Resolves aliases and adds path-prefix to paths
+ */
+export declare function resolvePath(filename: string): string;

package/dist/lib/path-utils/path.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Replacement for Node.js path.filename
+ * @param url
+ */
+export declare function filename(url: string): string;
+/**
+ * Replacement for Node.js path.dirname
+ * @param url
+ */
+export declare function dirname(url: string): string;
+/**
+ * Replacement for Node.js path.join
+ * @param parts
+ */
+export declare function join(...parts: string[]): string;

package/dist/lib/request-utils/request-scheduler.d.ts

@@ -0,0 +1,61 @@
+import { Stats } from '@probe.gl/stats';
+declare type Handle = any;
+declare type DoneFunction = () => any;
+declare type GetPriorityFunction = () => number;
+declare type RequestResult = {
+    done: DoneFunction;
+} | null;
+/** RequestScheduler Options */
+export declare type RequestSchedulerProps = {
+    id?: string;
+    throttleRequests?: boolean;
+    maxRequests?: number;
+};
+/** Tracks one request */
+declare type Request = {
+    handle: Handle;
+    priority: number;
+    getPriority: GetPriorityFunction;
+    resolve?: (value: any) => any;
+};
+/**
+ * Used to issue a request, without having them "deeply queued" by the browser.
+ * @todo - Track requests globally, across multiple servers
+ */
+export default class RequestScheduler {
+    readonly props: Required<RequestSchedulerProps>;
+    readonly stats: Stats;
+    activeRequestCount: number;
+    /** Tracks the number of active requests and prioritizes/cancels queued requests. */
+    private requestQueue;
+    private requestMap;
+    private deferredUpdate;
+    constructor(props?: RequestSchedulerProps);
+    /**
+     * Called by an application that wants to issue a request, without having it deeply queued by the browser
+     *
+     * When the returned promise resolved, it is OK for the application to issue a request.
+     * The promise resolves to an object that contains a `done` method.
+     * When the application's request has completed (or failed), the application must call the `done` function
+     *
+     * @param handle
+     * @param getPriority will be called when request "slots" open up,
+     *    allowing the caller to update priority or cancel the request
+     *    Highest priority executes first, priority < 0 cancels the request
+     * @returns a promise
+     *   - resolves to a object (with a `done` field) when the request can be issued without queueing,
+     *   - resolves to `null` if the request has been cancelled (by the callback return < 0).
+     *     In this case the application should not issue the request
+     */
+    scheduleRequest(handle: Handle, getPriority?: GetPriorityFunction): Promise<RequestResult>;
+    _issueRequest(request: Request): Promise<any>;
+    /** We check requests asynchronously, to prevent multiple updates */
+    _issueNewRequests(): void;
+    /** Refresh all requests  */
+    _issueNewRequestsAsync(): void;
+    /** Ensure all requests have updated priorities, and that no longer valid requests are cancelled */
+    _updateAllRequests(): void;
+    /** Update a single request by calling the callback */
+    _updateRequest(request: any): boolean;
+}
+export {};

package/dist/lib/worker-loader-utils/create-loader-worker.d.ts

@@ -0,0 +1,6 @@
+import type { LoaderWithParser } from '../../types';
+/**
+ * Set up a WebWorkerGlobalScope to talk with the main thread
+ * @param loader
+ */
+export declare function createLoaderWorker(loader: LoaderWithParser): void;

package/dist/lib/worker-loader-utils/parse-with-worker.d.ts

@@ -0,0 +1,14 @@
+import type { Loader, LoaderOptions, LoaderContext } from '../../types';
+/**
+ * Determines if a loader can parse with worker
+ * @param loader
+ * @param options
+ */
+export declare function canParseWithWorker(loader: Loader, options?: LoaderOptions): boolean | "" | undefined;
+/**
+ * this function expects that the worker function sends certain messages,
+ * this can be automated if the worker is wrapper by a call to createLoaderWorker in @loaders.gl/loader-utils.
+ */
+export declare function parseWithWorker(loader: Loader, data: any, options?: LoaderOptions, context?: LoaderContext, parseOnMainThread?: (arrayBuffer: ArrayBuffer, options: {
+    [key: string]: any;
+}) => Promise<void>): Promise<any>;

package/dist/types.d.ts

@@ -0,0 +1,206 @@
+/// <reference types="node" />
+export declare type TypedIntArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Int32Array | Uint32Array;
+export declare type TypedFloatArray = Uint16Array | Float32Array | Float64Array;
+export declare type TypedArray = TypedIntArray | TypedFloatArray;
+export declare type NumericArray = Array<number> | TypedIntArray | TypedFloatArray;
+declare type FetchLike = (url: string, options?: RequestInit) => Promise<Response>;
+export declare type LoaderOptions = {
+    /** fetch options or a custom fetch function */
+    fetch?: typeof fetch | FetchLike | RequestInit | null;
+    /** Do not throw on errors */
+    nothrow?: boolean;
+    /** loader selection, search first for supplied mimeType */
+    mimeType?: string;
+    /** loader selection, provide fallback mimeType is server does not provide */
+    fallbackMimeType?: string;
+    /** loader selection, avoid searching registered loaders */
+    ignoreRegisteredLoaders?: boolean;
+    /** Experimental: Supply a logger to the parser */
+    log?: any;
+    /** Size of each batch. `auto` matches batches to size of incoming chunks */
+    batchSize?: number | 'auto';
+    /** Minimal amount of time between batches */
+    batchDebounceMs?: number;
+    /** Stop loading after a given number of rows (compare SQL limit clause) */
+    limit?: 0;
+    /** Experimental: Stop loading after reaching */
+    _limitMB?: 0;
+    /** Generate metadata batches */
+    metadata?: boolean;
+    /** Transforms to run on incoming batches */
+    transforms?: TransformBatches[];
+    /** CDN load workers from */
+    CDN?: string;
+    /** Set to `false` to disable workers */
+    worker?: boolean;
+    /** Number of concurrent workers (per loader) on desktop browser */
+    maxConcurrency?: number;
+    /** Number of concurrent workers (per loader) on mobile browsers */
+    maxMobileConcurrency?: number;
+    /** Set to `false` to prevent reuse workers */
+    reuseWorkers?: boolean;
+    /** set to 'test' to run worker type */
+    _workerType?: string;
+    /** @deprecated `options.batchType` removed, Use `options.<loader>.type` instead */
+    batchType?: 'row' | 'columnar' | 'arrow';
+    /** @deprecated `options.throw removed`, Use `options.nothrow` instead */
+    throws?: boolean;
+    /** @deprecated `options.dataType` no longer used */
+    dataType?: any;
+    /** @deprecated `options.uri` no longer used */
+    uri?: any;
+    /** @deprecated `options.method` removed. Use `options.fetch.method` */
+    method?: any;
+    /** @deprecated `options.headers` removed. Use `options.fetch.headers` */
+    headers?: any;
+    /** @deprecated `options.body` removed. Use `options.fetch.body` */
+    body?: any;
+    /** @deprecated `options.mode` removed. Use `options.fetch.mode` */
+    mode?: any;
+    /** @deprecated `options.credentials` removed. Use `options.fetch.credentials` */
+    credentials?: any;
+    /** @deprecated `options.cache` removed. Use `options.fetch.cache` */
+    cache?: any;
+    /** @deprecated `options.redirect` removed. Use `options.fetch.redirect` */
+    redirect?: any;
+    /** @deprecated `options.referrer` removed. Use `options.fetch.referrer` */
+    referrer?: any;
+    /** @deprecated `options.referrerPolicy` removed. Use `options.fetch.referrerPolicy` */
+    referrerPolicy?: any;
+    /** @deprecated `options.integrity` removed. Use `options.fetch.integrity` */
+    integrity?: any;
+    /** @deprecated `options.keepalive` removed. Use `options.fetch.keepalive` */
+    keepalive?: any;
+    /** @deprecated `options.signal` removed. Use `options.fetch.signal` */
+    signal?: any;
+    [loaderId: string]: any;
+};
+declare type PreloadOptions = {
+    [key: string]: any;
+};
+/**
+ * A worker loader definition that can be used with `@loaders.gl/core` functions
+ */
+export declare type Loader = {
+    name: string;
+    id: string;
+    module: string;
+    version: string;
+    worker?: string | boolean;
+    options: object;
+    deprecatedOptions?: object;
+    category?: string;
+    extensions: string[];
+    mimeTypes: string[];
+    binary?: boolean;
+    text?: boolean;
+    tests?: (((ArrayBuffer: any) => boolean) | ArrayBuffer | string)[];
+    supported?: boolean;
+    testText?: (string: any) => boolean;
+};
+/**
+ * A "bundled" loader definition that can be used with `@loaders.gl/core` functions
+ * If a worker loader is supported it will also be supported.
+ */
+export declare type LoaderWithParser = Loader & {
+    testText?: (string: any) => boolean;
+    parse: Parse;
+    preload?: Preload;
+    parseSync?: ParseSync;
+    parseText?: ParseText;
+    parseTextSync?: ParseTextSync;
+    parseInBatches?: ParseInBatches;
+    parseFileInBatches?: ParseFileInBatches;
+};
+/** Options for writers */
+export declare type WriterOptions = {};
+/**
+ * A writer definition that can be used with `@loaders.gl/core` functions
+ */
+export declare type Writer = {
+    name: string;
+    id: string;
+    module: string;
+    version: string;
+    options: object;
+    deprecatedOptions?: object;
+    binary?: boolean;
+    extensions?: string[];
+    mimeTypes?: string[];
+    text?: boolean;
+    encode?: Encode;
+    encodeSync?: EncodeSync;
+    encodeInBatches?: EncodeInBatches;
+    encodeURLtoURL?: EncodeURLtoURL;
+    encodeText?: EncodeText;
+};
+export declare type LoaderContext = {
+    loaders?: Loader[] | null;
+    url?: string;
+    fetch: typeof fetch;
+    parse: (arrayBuffer: ArrayBuffer, loaders?: any, options?: LoaderOptions, context?: LoaderContext) => Promise<any>;
+    parseSync?: (arrayBuffer: ArrayBuffer, loaders?: any, options?: LoaderOptions, context?: LoaderContext) => any;
+    parseInBatches?: (iterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>, loaders?: any, options?: LoaderOptions, context?: LoaderContext) => AsyncIterable<any> | Promise<AsyncIterable<any>>;
+};
+declare type Parse = (arrayBuffer: ArrayBuffer, options?: LoaderOptions, context?: LoaderContext) => Promise<any>;
+declare type ParseSync = (arrayBuffer: ArrayBuffer, options?: LoaderOptions, context?: LoaderContext) => any;
+declare type ParseText = (text: string, options?: LoaderOptions) => Promise<any>;
+declare type ParseTextSync = (text: string, options?: LoaderOptions) => any;
+declare type ParseInBatches = (iterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>, options?: LoaderOptions, context?: LoaderContext) => AsyncIterable<any>;
+declare type ParseFileInBatches = (file: Blob, options?: LoaderOptions, context?: LoaderContext) => AsyncIterable<any>;
+declare type Encode = (data: any, options?: WriterOptions) => Promise<ArrayBuffer>;
+declare type EncodeSync = (data: any, options?: WriterOptions) => ArrayBuffer;
+declare type EncodeText = Function;
+declare type EncodeInBatches = Function;
+declare type EncodeURLtoURL = (inputUrl: string, outputUrl: string, options?: WriterOptions) => Promise<string>;
+declare type Preload = (url: string, options?: PreloadOptions) => any;
+export declare type TransformBatches = (asyncIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>) => AsyncIterable<ArrayBuffer>;
+/** Types that can be synchronously parsed */
+export declare type SyncDataType = string | ArrayBuffer;
+/** Types that can be parsed async */
+export declare type DataType = string | ArrayBuffer | File | Blob | Response | ReadableStream | Iterable<ArrayBuffer> | AsyncIterable<ArrayBuffer>;
+/** Types that can be parsed in batches */
+export declare type BatchableDataType = DataType | Iterable<ArrayBuffer> | AsyncIterable<ArrayBuffer> | Promise<AsyncIterable<ArrayBuffer>>;
+/**
+ * A FileSystem interface can encapsulate a FileList, a ZipFile, a GoogleDrive etc.
+ */
+export interface IFileSystem {
+    /**
+     * Return a list of file names
+     * @param dirname directory name. file system root directory if omitted
+     */
+    readdir(dirname?: string, options?: {
+        recursive?: boolean;
+    }): Promise<string[]>;
+    /**
+     * Gets information from a local file from the filesystem
+     * @param filename file name to stat
+     * @param options currently unused
+     * @throws if filename is not in local filesystem
+     */
+    stat(filename: string, options?: object): Promise<{
+        size: number;
+    }>;
+    /**
+     * Fetches a local file from the filesystem (or a URL)
+     * @param filename
+     * @param options
+     */
+    fetch(filename: string, options?: object): Promise<Response>;
+}
+declare type ReadOptions = {
+    buffer?: ArrayBuffer;
+    offset?: number;
+    length?: number;
+    position?: number;
+};
+export interface IRandomAccessReadFileSystem extends IFileSystem {
+    open(path: string, flags: any, mode?: any): Promise<any>;
+    close(fd: any): Promise<void>;
+    fstat(fd: any): Promise<object>;
+    read(fd: any, options?: ReadOptions): Promise<{
+        bytesRead: number;
+        buffer: Buffer;
+    }>;
+}
+export {};

package/dist/workers/json-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loaders.gl/loader-utils",
-  "version": "3.1.0-alpha.1",
+  "version": "3.1.0-alpha.5",
   "description": "Framework-independent loaders for 3D graphics formats",
   "license": "MIT",
   "publishConfig": {
@@ -17,9 +17,9 @@
     "mesh",
     "point cloud"
   ],
-  "types": "src/index.ts",
-  "main": "dist/index.js",
-  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "main": "dist/es5/index.js",
+  "module": "dist/esm/index.js",
   "sideEffects": false,
   "files": [
     "src",
@@ -27,25 +27,30 @@
     "README.md"
   ],
   "browser": {
-    "./src/lib/node/buffer-utils.node.ts": false,
-    "./src/lib/node/buffer-utils.node.js": false,
-    "./dist/es5/lib/node/buffer-utils.node.js": false,
-    "./dist/esm/lib/node/buffer-utils.node.js": false,
+    "./src/lib/node/buffer.ts": false,
+    "./src/lib/node/buffer.js": false,
+    "./dist/es5/lib/node/buffer.js": false,
+    "./dist/esm/lib/node/buffer.js": false,
     "./src/lib/node/fs.ts": false,
     "./src/lib/node/fs.js": false,
     "./dist/es5/lib/node/fs.js": false,
     "./dist/esm/lib/node/fs.js": false,
+    "./src/lib/node/util.ts": false,
+    "./src/lib/node/util.js": false,
+    "./dist/es5/lib/node/util.js": false,
+    "./dist/esm/lib/node/util.js": false,
     "fs": false,
     "util": false
   },
   "scripts": {
     "pre-build-disabled": "npm run build-bundle",
+    "post-build": "tsc",
     "build-bundle": "webpack --config ../../scripts/webpack/bundle.js"
   },
   "dependencies": {
     "@babel/runtime": "^7.3.1",
-    "@loaders.gl/worker-utils": "3.1.0-alpha.1",
+    "@loaders.gl/worker-utils": "3.1.0-alpha.5",
     "@probe.gl/stats": "^3.4.0"
   },
-  "gitHead": "725f6ceeb9d76dacff6305f01bc45873680f17d5"
+  "gitHead": "352241dd910a8c6307a235dadbe154ca915b885b"
 }

package/src/index.ts

@@ -64,17 +64,35 @@ export {forEach, concatenateArrayBuffersAsync} from './lib/iterators/async-itera
 // REQUEST UTILS
 export {default as RequestScheduler} from './lib/request-utils/request-scheduler';
 
-// NODE `path`` REPLACEMENT
-import * as path from './lib/path-utils/path';
-export {path};
+// PATH HELPERS
 export {setPathPrefix, getPathPrefix, resolvePath} from './lib/path-utils/file-aliases';
 export {addAliases as _addAliases} from './lib/path-utils/file-aliases';
 
-// NODE `fs` WRAPPERS
-import * as fs from './lib/node/fs';
-export {fs};
+// MICRO LOADERS
+export {JSONLoader} from './json-loader';
+
+// NODE support
+
+// Node.js emulation (can be used in browser)
+
+// `path` replacement (avoids bundling big path polyfill)
+import * as path from './lib/path-utils/path';
+export {path};
 
-// NODE `buffer` WRAPPERS
+// Avoid direct use of `Buffer` which pulls in 50KB polyfill
 export {isBuffer, toBuffer, bufferToArrayBuffer} from './lib/binary-utils/buffer-utils';
 
-export {JSONLoader} from './json-loader';
+// Note.js wrappers (can be safely imported, but not used in browser)
+
+// Use instead of importing 'util'
+import * as util from './lib/node/util';
+export {util};
+// TODO - remove
+export {promisify} from './lib/node/util';
+
+// Use instead of importing 'fs';`
+import * as fs from './lib/node/fs';
+export {fs};
+
+// EXPERIMENTAL
+export {default as _NodeFileSystem} from './lib/filesystems/node-filesystem';

package/src/lib/binary-utils/buffer-utils.ts

@@ -1,4 +1,4 @@
-import * as node from '../node/buffer-utils.node';
+import * as node from '../node/buffer';
 
 /**
  * Check for Node.js `Buffer` (without triggering bundler to include Buffer polyfill on browser)

package/src/lib/env-utils/globals.ts

@@ -20,7 +20,7 @@ export {self_ as self, window_ as window, global_ as global, document_ as docume
 /** true if running in a browser */
 export const isBrowser: boolean =
   // @ts-ignore process does not exist on browser
-  typeof process !== 'object' || String(process) !== '[object process]' || process.browser;
+  Boolean(typeof process !== 'object' || String(process) !== '[object process]' || process.browser);
 
 /** true if running in a worker thread */
 export const isWorker: boolean = typeof importScripts === 'function';

package/src/lib/filesystems/node-filesystem.ts

@@ -0,0 +1,79 @@
+import * as fs from '../node/fs';
+import {IFileSystem, IRandomAccessReadFileSystem} from '../../types';
+// import {fetchFile} from "../fetch/fetch-file"
+// import {selectLoader} from "../api/select-loader";
+
+type Stat = {
+  size: number;
+  isDirectory: () => boolean;
+  info?: fs.Stats;
+};
+
+type ReadOptions = {
+  buffer?: Buffer;
+  offset?: number;
+  length?: number;
+  position?: number;
+};
+
+/**
+ * FileSystem pass-through for Node.js
+ * Compatible with BrowserFileSystem.
+ * @param options
+ */
+export default class NodeFileSystem implements IFileSystem, IRandomAccessReadFileSystem {
+  // implements IFileSystem
+  constructor(options: {[key: string]: any}) {
+    this.fetch = options._fetch;
+  }
+
+  async readdir(dirname = '.', options?: {}): Promise<any[]> {
+    return await fs.readdir(dirname, options);
+  }
+
+  async stat(path: string, options?: {}): Promise<Stat> {
+    const info = await fs.stat(path, options);
+    return {size: Number(info.size), isDirectory: () => false, info};
+  }
+
+  async fetch(path: string, options: {[key: string]: any}) {
+    // Falls back to handle https:/http:/data: etc fetches
+    // eslint-disable-next-line
+    const fallbackFetch = options.fetch || this.fetch;
+    return fallbackFetch(path, options);
+  }
+
+  // implements IRandomAccessFileSystem
+  async open(path: string, flags: string | number, mode?: any): Promise<number> {
+    return await fs.open(path, flags);
+  }
+
+  async close(fd: number): Promise<void> {
+    return await fs.close(fd);
+  }
+
+  async fstat(fd: number): Promise<Stat> {
+    const info = await fs.fstat(fd);
+    return info;
+  }
+
+  async read(
+    fd: number,
+    // @ts-ignore Possibly null
+    {buffer = null, offset = 0, length = buffer.byteLength, position = null}: ReadOptions
+  ): Promise<{bytesRead: number; buffer: Buffer}> {
+    let totalBytesRead = 0;
+    // Read in loop until we get required number of bytes
+    while (totalBytesRead < length) {
+      const {bytesRead} = await fs.read(
+        fd,
+        buffer,
+        offset + totalBytesRead,
+        length - totalBytesRead,
+        position + totalBytesRead
+      );
+      totalBytesRead += bytesRead;
+    }
+    return {bytesRead: totalBytesRead, buffer};
+  }
+}

package/src/lib/node/fs.ts

@@ -1,22 +1,38 @@
 // fs wrapper (promisified fs + avoids bundling fs in browsers)
 import fs from 'fs';
-import {toArrayBuffer} from './buffer-utils.node';
-import {promisify} from 'util';
+import {toArrayBuffer} from './buffer';
+import {promisify} from './util';
 
-const error = (fsFunction) => () => {
-  throw new Error(`${fsFunction} not available in browser`);
-};
+export type {Stats} from 'fs';
 
-export const isSupported = Boolean(fs);
+// paths
+
+/** Wrapper for Node.js fs method */
+export const readdir = promisify(fs.readdir);
+/** Wrapper for Node.js fs method */
+export const stat = promisify(fs.stat);
+
+/** Wrapper for Node.js fs method */
+export const readFile = promisify(fs.readFile);
+/** Wrapper for Node.js fs method */
+export const readFileSync = fs.readFileSync;
+/** Wrapper for Node.js fs method */
+export const writeFile = promisify(fs.writeFile);
+/** Wrapper for Node.js fs method */
+export const writeFileSync = fs.writeFileSync;
 
-export const open = fs?.open ? promisify(fs.open) : error('fs.open');
-export const close = fs?.close ? promisify(fs.close) : error('fs.close');
-export const read = fs?.read ? promisify(fs.read) : error('fs.read');
+// file descriptors
 
-export const readFile = fs?.readFile ? promisify(fs.readFile) : error('fs.readFile');
-export const readFileSync = fs?.readFileSync ? fs.readFileSync : error('fs.readFileSync');
-export const writeFile = fs?.writeFile ? promisify(fs.writeFile) : error('fs.writeFile');
-export const writeFileSync = fs?.writeFileSync ? fs.writeFileSync : error('fs.writeFileSync');
+/** Wrapper for Node.js fs method */
+export const open = promisify(fs.open);
+/** Wrapper for Node.js fs method */
+export const close = promisify(fs.close);
+/** Wrapper for Node.js fs method */
+export const read = promisify(fs.read);
+/** Wrapper for Node.js fs method */
+export const fstat = promisify(fs.fstat);
+
+export const isSupported = Boolean(fs);
 
 export async function _readToArrayBuffer(fd: number, start: number, length: number) {
   const buffer = Buffer.alloc(length);

package/src/lib/node/util.ts

@@ -0,0 +1,4 @@
+import * as util from 'util';
+
+/** Wrapper for Node.js promisify */
+export const promisify = util.promisify;

package/src/lib/path-utils/path.ts

@@ -1,5 +1,14 @@
 // Beginning of a minimal implementation of the Node.js path API, that doesn't pull in big polyfills.
 
+/**
+ * Replacement for Node.js path.filename
+ * @param url
+ */
+export function filename(url: string): string {
+  const slashIndex = url && url.lastIndexOf('/');
+  return slashIndex >= 0 ? url.substr((slashIndex as number) + 1) : '';
+}
+
 /**
  * Replacement for Node.js path.dirname
  * @param url

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/index.ts"],"names":["assert","isBrowser","isWorker","nodeVersion","self","window","global","document","createLoaderWorker","parseWithWorker","canParseWithWorker","parseJSON","toArrayBuffer","sliceArrayBuffer","concatenateArrayBuffers","concatenateTypedArrays","compareArrayBuffers","padToNBytes","copyToArray","copyArrayBuffer","copyPaddedArrayBufferToDataView","copyPaddedStringToDataView","padStringToByteAlignment","copyStringToDataView","copyBinaryToDataView","getFirstCharacters","getMagicString","makeTextEncoderIterator","makeTextDecoderIterator","makeLineIterator","makeNumberedLineIterator","forEach","concatenateArrayBuffersAsync","default","RequestScheduler","path","setPathPrefix","getPathPrefix","resolvePath","addAliases","_addAliases","fs","isBuffer","toBuffer","bufferToArrayBuffer","JSONLoader"],"mappings":"AAgBA,SAAQA,MAAR,QAAqB,wBAArB;AACA,SACEC,SADF,EAEEC,QAFF,EAGEC,WAHF,EAIEC,IAJF,EAKEC,MALF,EAMEC,MANF,EAOEC,QAPF,QAQO,yBARP;AAWA,SAAQC,kBAAR,QAAiC,gDAAjC;AACA,SAAQC,eAAR,EAAyBC,kBAAzB,QAAkD,6CAAlD;AAGA,SAAQC,SAAR,QAAwB,+BAAxB;AAGA,SACEC,aADF,EAEEC,gBAFF,EAGEC,uBAHF,EAIEC,sBAJF,EAKEC,mBALF,QAMO,uCANP;AAOA,SAAQC,WAAR,EAAqBC,WAArB,EAAkCC,eAAlC,QAAwD,sCAAxD;AACA,SACEC,+BADF,EAEEC,0BAFF,QAGO,sCAHP;AAIA,SACEC,wBADF,EAEEC,oBAFF,EAGEC,oBAHF,QAIO,iCAJP;AAKA,SAAQC,kBAAR,EAA4BC,cAA5B,QAAiD,yCAAjD;AAGA,SACEC,uBADF,EAEEC,uBAFF,EAGEC,gBAHF,EAIEC,wBAJF,QAKO,gCALP;AAMA,SAAQC,OAAR,EAAiBC,4BAAjB,QAAoD,iCAApD;AAGA,SAAQC,OAAO,IAAIC,gBAAnB,QAA0C,uCAA1C;AAGA,OAAO,KAAKC,IAAZ,MAAsB,uBAAtB;AACA,SAAQA,IAAR;AACA,SAAQC,aAAR,EAAuBC,aAAvB,EAAsCC,WAAtC,QAAwD,+BAAxD;AACA,SAAQC,UAAU,IAAIC,WAAtB,QAAwC,+BAAxC;AAGA,OAAO,KAAKC,EAAZ,MAAoB,eAApB;AACA,SAAQA,EAAR;AAGA,SAAQC,QAAR,EAAkBC,QAAlB,EAA4BC,mBAA5B,QAAsD,iCAAtD;AAEA,SAAQC,UAAR,QAAyB,eAAzB","sourcesContent":["// TYPES\nexport type {\n  Loader,\n  LoaderWithParser,\n  LoaderContext,\n  LoaderOptions,\n  Writer,\n  WriterOptions,\n  DataType,\n  SyncDataType,\n  BatchableDataType,\n  IFileSystem,\n  IRandomAccessReadFileSystem\n} from './types';\n\n// GENERAL UTILS\nexport {assert} from './lib/env-utils/assert';\nexport {\n  isBrowser,\n  isWorker,\n  nodeVersion,\n  self,\n  window,\n  global,\n  document\n} from './lib/env-utils/globals';\n\n// LOADERS.GL-SPECIFIC WORKER UTILS\nexport {createLoaderWorker} from './lib/worker-loader-utils/create-loader-worker';\nexport {parseWithWorker, canParseWithWorker} from './lib/worker-loader-utils/parse-with-worker';\n\n// PARSER UTILS\nexport {parseJSON} from './lib/parser-utils/parse-json';\n\n// MEMORY COPY UTILS\nexport {\n  toArrayBuffer,\n  sliceArrayBuffer,\n  concatenateArrayBuffers,\n  concatenateTypedArrays,\n  compareArrayBuffers\n} from './lib/binary-utils/array-buffer-utils';\nexport {padToNBytes, copyToArray, copyArrayBuffer} from './lib/binary-utils/memory-copy-utils';\nexport {\n  copyPaddedArrayBufferToDataView,\n  copyPaddedStringToDataView\n} from './lib/binary-utils/binary-copy-utils';\nexport {\n  padStringToByteAlignment,\n  copyStringToDataView,\n  copyBinaryToDataView\n} from './lib/binary-utils/encode-utils';\nexport {getFirstCharacters, getMagicString} from './lib/binary-utils/get-first-characters';\n\n// ITERATOR UTILS\nexport {\n  makeTextEncoderIterator,\n  makeTextDecoderIterator,\n  makeLineIterator,\n  makeNumberedLineIterator\n} from './lib/iterators/text-iterators';\nexport {forEach, concatenateArrayBuffersAsync} from './lib/iterators/async-iteration';\n\n// REQUEST UTILS\nexport {default as RequestScheduler} from './lib/request-utils/request-scheduler';\n\n// NODE `path`` REPLACEMENT\nimport * as path from './lib/path-utils/path';\nexport {path};\nexport {setPathPrefix, getPathPrefix, resolvePath} from './lib/path-utils/file-aliases';\nexport {addAliases as _addAliases} from './lib/path-utils/file-aliases';\n\n// NODE `fs` WRAPPERS\nimport * as fs from './lib/node/fs';\nexport {fs};\n\n// NODE `buffer` WRAPPERS\nexport {isBuffer, toBuffer, bufferToArrayBuffer} from './lib/binary-utils/buffer-utils';\n\nexport {JSONLoader} from './json-loader';\n"],"file":"index.js"}

package/dist/json-loader.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/json-loader.ts"],"names":["VERSION","JSONLoader","name","id","module","version","extensions","mimeTypes","category","text","parseTextSync","parse","arrayBuffer","TextDecoder","decode","options","JSON","_typecheckJSONLoader"],"mappings":"AAIA,MAAMA,OAAO,GAAG,2BAAuB,WAAvB,qBAAmD,QAAnE;AAMA,OAAO,MAAMC,UAAU,GAAG;AACxBC,EAAAA,IAAI,EAAE,MADkB;AAExBC,EAAAA,EAAE,EAAE,MAFoB;AAGxBC,EAAAA,MAAM,EAAE,MAHgB;AAIxBC,EAAAA,OAAO,EAAEL,OAJe;AAKxBM,EAAAA,UAAU,EAAE,CAAC,MAAD,EAAS,SAAT,CALY;AAMxBC,EAAAA,SAAS,EAAE,CAAC,kBAAD,CANa;AAOxBC,EAAAA,QAAQ,EAAE,MAPc;AAQxBC,EAAAA,IAAI,EAAE,IARkB;AASxBC,EAAAA,aATwB;AAUxBC,EAAAA,KAAK,EAAE,MAAOC,WAAP,IAAuBF,aAAa,CAAC,IAAIG,WAAJ,GAAkBC,MAAlB,CAAyBF,WAAzB,CAAD,CAVnB;AAWxBG,EAAAA,OAAO,EAAE;AAXe,CAAnB;;AAeP,SAASL,aAAT,CAAuBD,IAAvB,EAA6B;AAC3B,SAAOO,IAAI,CAACL,KAAL,CAAWF,IAAX,CAAP;AACD;;AAED,OAAO,MAAMQ,oBAAsC,GAAGhB,UAA/C","sourcesContent":["import type {LoaderWithParser} from './types';\n\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n\n/**\n * A JSON Micro loader (minimal bundle size)\n * Alternative to `@loaders.gl/json`\n */\nexport const JSONLoader = {\n  name: 'JSON',\n  id: 'json',\n  module: 'json',\n  version: VERSION,\n  extensions: ['json', 'geojson'],\n  mimeTypes: ['application/json'],\n  category: 'json',\n  text: true,\n  parseTextSync,\n  parse: async (arrayBuffer) => parseTextSync(new TextDecoder().decode(arrayBuffer)),\n  options: {}\n};\n\n// TODO - deprecated\nfunction parseTextSync(text) {\n  return JSON.parse(text);\n}\n\nexport const _typecheckJSONLoader: LoaderWithParser = JSONLoader;\n"],"file":"json-loader.js"}

package/dist/lib/binary-utils/array-buffer-utils.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/lib/binary-utils/array-buffer-utils.ts"],"names":["isBuffer","bufferToArrayBuffer","toArrayBuffer","data","ArrayBuffer","isView","byteOffset","byteLength","buffer","slice","text","uint8Array","TextEncoder","encode","_toArrayBuffer","Error","compareArrayBuffers","arrayBuffer1","arrayBuffer2","array1","Uint8Array","array2","i","length","concatenateArrayBuffers","sources","sourceArrays","map","source2","reduce","typedArray","result","offset","sourceArray","set","concatenateTypedArrays","typedArrays","arrays","TypedArrayConstructor","constructor","sumLength","acc","value","array","sliceArrayBuffer","arrayBuffer","subArray","undefined","subarray","arrayCopy"],"mappings":"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","sourcesContent":["import {TypedArray} from '../../types';\nimport {isBuffer, bufferToArrayBuffer} from './buffer-utils';\n\n/**\n * Convert an object to an array buffer\n */\nexport function toArrayBuffer(data: any): ArrayBuffer {\n  // Note: Should be called first, Buffers can trigger other detections below\n  if (isBuffer(data)) {\n    return bufferToArrayBuffer(data);\n  }\n\n  if (data instanceof ArrayBuffer) {\n    return data;\n  }\n\n  // Careful - Node Buffers look like Uint8Arrays (keep after isBuffer)\n  if (ArrayBuffer.isView(data)) {\n    if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) {\n      return data.buffer;\n    }\n    return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);\n  }\n\n  if (typeof data === 'string') {\n    const text = data;\n    const uint8Array = new TextEncoder().encode(text);\n    return uint8Array.buffer;\n  }\n\n  // HACK to support Blob polyfill\n  if (data && typeof data === 'object' && data._toArrayBuffer) {\n    return data._toArrayBuffer();\n  }\n\n  throw new Error('toArrayBuffer');\n}\n\n/**\n * compare two binary arrays for equality\n * @param {ArrayBuffer} a\n * @param {ArrayBuffer} b\n * @param {number} byteLength\n */\nexport function compareArrayBuffers(\n  arrayBuffer1: ArrayBuffer,\n  arrayBuffer2: ArrayBuffer,\n  byteLength?: number\n): boolean {\n  byteLength = byteLength || arrayBuffer1.byteLength;\n  if (arrayBuffer1.byteLength < byteLength || arrayBuffer2.byteLength < byteLength) {\n    return false;\n  }\n  const array1 = new Uint8Array(arrayBuffer1);\n  const array2 = new Uint8Array(arrayBuffer2);\n  for (let i = 0; i < array1.length; ++i) {\n    if (array1[i] !== array2[i]) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Concatenate a sequence of ArrayBuffers\n * @return A concatenated ArrayBuffer\n */\nexport function concatenateArrayBuffers(...sources: (ArrayBuffer | Uint8Array)[]): ArrayBuffer {\n  // Make sure all inputs are wrapped in typed arrays\n  const sourceArrays = sources.map((source2) =>\n    source2 instanceof ArrayBuffer ? new Uint8Array(source2) : source2\n  );\n\n  // Get length of all inputs\n  const byteLength = sourceArrays.reduce((length, typedArray) => length + typedArray.byteLength, 0);\n\n  // Allocate array with space for all inputs\n  const result = new Uint8Array(byteLength);\n\n  // Copy the subarrays\n  let offset = 0;\n  for (const sourceArray of sourceArrays) {\n    result.set(sourceArray, offset);\n    offset += sourceArray.byteLength;\n  }\n\n  // We work with ArrayBuffers, discard the typed array wrapper\n  return result.buffer;\n}\n\n/**\n * Concatenate arbitrary count of typed arrays\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Typed_arrays\n * @param {...*} arrays - list of arrays. All arrays should be the same type\n * @return A concatenated TypedArray\n */\nexport function concatenateTypedArrays<T>(...typedArrays: T[]): T {\n  // @ts-ignore\n  const arrays = typedArrays as TypedArray[];\n  // @ts-ignore\n  const TypedArrayConstructor = (arrays && arrays.length > 1 && arrays[0].constructor) || null;\n  if (!TypedArrayConstructor) {\n    throw new Error(\n      '\"concatenateTypedArrays\" - incorrect quantity of arguments or arguments have incompatible data types'\n    );\n  }\n\n  const sumLength = arrays.reduce((acc, value) => acc + value.length, 0);\n  // @ts-ignore typescript does not like dynamic constructors\n  const result = new TypedArrayConstructor(sumLength);\n  let offset = 0;\n  for (const array of arrays) {\n    result.set(array, offset);\n    offset += array.length;\n  }\n  return result;\n}\n\n/**\n * Copy a view of an ArrayBuffer into new ArrayBuffer with byteOffset = 0\n * @param arrayBuffer\n * @param byteOffset\n * @param byteLength\n */\nexport function sliceArrayBuffer(\n  arrayBuffer: ArrayBuffer,\n  byteOffset: number,\n  byteLength?: number\n): ArrayBuffer {\n  const subArray =\n    byteLength !== undefined\n      ? new Uint8Array(arrayBuffer).subarray(byteOffset, byteOffset + byteLength)\n      : new Uint8Array(arrayBuffer).subarray(byteOffset);\n  const arrayCopy = new Uint8Array(subArray);\n  return arrayCopy.buffer;\n}\n"],"file":"array-buffer-utils.js"}