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

package/dist/lib/api/parse-sync.js

@@ -1,57 +1,59 @@
-import { assert } from '@loaders.gl/loader-utils';
-import { selectLoaderSync } from './select-loader';
-import { isLoaderObject } from '../loader-utils/normalize-loader';
-import { normalizeOptions } from '../loader-utils/option-utils';
-import { getArrayBufferOrStringFromDataSync } from '../loader-utils/get-data';
-import { getLoaderContext, getLoadersFromContext } from '../loader-utils/loader-context';
-import { getResourceUrlAndType } from '../utils/resource-utils';
-export function parseSync(data, loaders, options, context) {
-  assert(!context || typeof context === 'object');
-
-  if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {
-    context = undefined;
-    options = loaders;
-    loaders = undefined;
-  }
-
-  options = options || {};
-  const typedLoaders = loaders;
-  const candidateLoaders = getLoadersFromContext(typedLoaders, context);
-  const loader = selectLoaderSync(data, candidateLoaders, options);
-
-  if (!loader) {
-    return null;
-  }
-
-  options = normalizeOptions(options, loader, candidateLoaders);
-  const {
-    url
-  } = getResourceUrlAndType(data);
-
-  const parse = () => {
-    throw new Error('parseSync called parse');
-  };
-
-  context = getLoaderContext({
-    url,
-    parseSync,
-    parse,
-    loaders: loaders
-  }, options);
-  return parseWithLoaderSync(loader, data, options, context);
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSync = void 0;
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+const select_loader_1 = require("./select-loader");
+const normalize_loader_1 = require("../loader-utils/normalize-loader");
+const option_utils_1 = require("../loader-utils/option-utils");
+const get_data_1 = require("../loader-utils/get-data");
+const loader_context_1 = require("../loader-utils/loader-context");
+const resource_utils_1 = require("../utils/resource-utils");
+/**
+ * Parses `data` synchronously using a specified loader
+ * @param data
+ * @param loaders
+ * @param options
+ * @param context
+ */
+function parseSync(data, loaders, options, context) {
+    (0, loader_utils_1.assert)(!context || typeof context === 'object'); // parseSync no longer accepts final url
+    // Signature: parseSync(data, options)
+    // Uses registered loaders
+    if (!Array.isArray(loaders) && !(0, normalize_loader_1.isLoaderObject)(loaders)) {
+        context = undefined; // context not supported in short signature
+        options = loaders;
+        loaders = undefined;
+    }
+    options = options || {};
+    // Chooses a loader (and normalizes it)
+    // Also use any loaders in the context, new loaders take priority
+    const typedLoaders = loaders;
+    const candidateLoaders = (0, loader_context_1.getLoadersFromContext)(typedLoaders, context);
+    const loader = (0, select_loader_1.selectLoaderSync)(data, candidateLoaders, options);
+    // Note: if nothrow option was set, it is possible that no loader was found, if so just return null
+    if (!loader) {
+        return null;
+    }
+    // Normalize options
+    options = (0, option_utils_1.normalizeOptions)(options, loader, candidateLoaders);
+    // Extract a url for auto detection
+    const { url } = (0, resource_utils_1.getResourceUrlAndType)(data);
+    const parse = () => {
+        throw new Error('parseSync called parse');
+    };
+    context = (0, loader_context_1.getLoaderContext)({ url, parseSync, parse, loaders: loaders }, options);
+    return parseWithLoaderSync(loader, data, options, context);
 }
-
+exports.parseSync = parseSync;
+// TODO - should accept loader.parseSync/parse and generate 1 chunk asyncIterator
 function parseWithLoaderSync(loader, data, options, context) {
-  data = getArrayBufferOrStringFromDataSync(data, loader, options);
-
-  if (loader.parseTextSync && typeof data === 'string') {
-    return loader.parseTextSync(data, options);
-  }
-
-  if (loader.parseSync && data instanceof ArrayBuffer) {
-    return loader.parseSync(data, options, context);
-  }
-
-  throw new Error("".concat(loader.name, " loader: 'parseSync' not supported by this loader, use 'parse' instead. ").concat(context.url || ''));
+    data = (0, get_data_1.getArrayBufferOrStringFromDataSync)(data, loader, options);
+    if (loader.parseTextSync && typeof data === 'string') {
+        return loader.parseTextSync(data, options); // , context, loader);
+    }
+    if (loader.parseSync && data instanceof ArrayBuffer) {
+        return loader.parseSync(data, options, context); // , loader);
+    }
+    // TBD - If synchronous parser not available, return null
+    throw new Error(`${loader.name} loader: 'parseSync' not supported by this loader, use 'parse' instead. ${context.url || ''}`);
 }
-//# sourceMappingURL=parse-sync.js.map

package/dist/lib/api/parse.d.ts

@@ -1,10 +1,6 @@
 import type { DataType, Loader, LoaderContext, LoaderOptions } from '@loaders.gl/loader-utils';
-/**
- * Parses `data` using a specified loader
- * @param data
- * @param loaders
- * @param options
- * @param context
- */
-export declare function parse(data: DataType | Promise<DataType>, loaders?: Loader | Loader[] | LoaderOptions, options?: LoaderOptions, context?: LoaderContext): Promise<any>;
+import type { LoaderOptionsType, LoaderReturnType } from '@loaders.gl/loader-utils';
+export declare function parse<LoaderT extends Loader, OptionsT extends LoaderOptions = LoaderOptionsType<LoaderT>>(data: DataType | Promise<DataType>, loader: LoaderT, options?: OptionsT, context?: LoaderContext): Promise<LoaderReturnType<LoaderT>>;
+export declare function parse(data: DataType | Promise<DataType>, loaders: Loader[], options?: LoaderOptions, context?: LoaderContext): Promise<any>;
+export declare function parse(data: DataType | Promise<DataType>, options?: LoaderOptions): Promise<any>;
 //# sourceMappingURL=parse.d.ts.map

package/dist/lib/api/parse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../../src/lib/api/parse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,QAAQ,EAAE,MAAM,EAAE,aAAa,EAAE,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAU7F;;;;;;GAMG;AACH,wBAAsB,KAAK,CACzB,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,EAClC,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,aAAa,EAC3C,OAAO,CAAC,EAAE,aAAa,EACvB,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,GAAG,CAAC,CAmCd"}
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../../src/lib/api/parse.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,QAAQ,EAAE,MAAM,EAAE,aAAa,EAAE,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAC7F,OAAO,KAAK,EAAC,iBAAiB,EAAE,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAalF,wBAAsB,KAAK,CACzB,OAAO,SAAS,MAAM,EACtB,QAAQ,SAAS,aAAa,GAAG,iBAAiB,CAAC,OAAO,CAAC,EAE3D,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,EAClC,MAAM,EAAE,OAAO,EACf,OAAO,CAAC,EAAE,QAAQ,EAClB,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC,CAAC;AAEtC,wBAAsB,KAAK,CACzB,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,EAClC,OAAO,EAAE,MAAM,EAAE,EACjB,OAAO,CAAC,EAAE,aAAa,EACvB,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,GAAG,CAAC,CAAC;AAEhB,wBAAsB,KAAK,CACzB,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,EAClC,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,GAAG,CAAC,CAAC"}

package/dist/lib/api/parse.js

@@ -1,64 +1,84 @@
-import { assert, validateWorkerVersion } from '@loaders.gl/worker-utils';
-import { parseWithWorker, canParseWithWorker } from '@loaders.gl/loader-utils';
-import { isLoaderObject } from '../loader-utils/normalize-loader';
-import { normalizeOptions } from '../loader-utils/option-utils';
-import { getArrayBufferOrStringFromData } from '../loader-utils/get-data';
-import { getLoaderContext, getLoadersFromContext } from '../loader-utils/loader-context';
-import { getResourceUrlAndType } from '../utils/resource-utils';
-import { selectLoader } from './select-loader';
-export async function parse(data, loaders, options, context) {
-  assert(!context || typeof context === 'object');
-
-  if (loaders && !Array.isArray(loaders) && !isLoaderObject(loaders)) {
-    context = undefined;
-    options = loaders;
-    loaders = undefined;
-  }
-
-  data = await data;
-  options = options || {};
-  const {
-    url
-  } = getResourceUrlAndType(data);
-  const typedLoaders = loaders;
-  const candidateLoaders = getLoadersFromContext(typedLoaders, context);
-  const loader = await selectLoader(data, candidateLoaders, options);
-
-  if (!loader) {
-    return null;
-  }
-
-  options = normalizeOptions(options, loader, candidateLoaders, url);
-  context = getLoaderContext({
-    url,
-    parse,
-    loaders: candidateLoaders
-  }, options, context);
-  return await parseWithLoader(loader, data, options, context);
+"use strict";
+// loaders.gl, MIT license
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = void 0;
+const worker_utils_1 = require("@loaders.gl/worker-utils");
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+const normalize_loader_1 = require("../loader-utils/normalize-loader");
+const is_type_1 = require("../../javascript-utils/is-type");
+const option_utils_1 = require("../loader-utils/option-utils");
+const get_data_1 = require("../loader-utils/get-data");
+const loader_context_1 = require("../loader-utils/loader-context");
+const resource_utils_1 = require("../utils/resource-utils");
+const select_loader_1 = require("./select-loader");
+/**
+ * Parses `data` using a specified loader
+ * @param data
+ * @param loaders
+ * @param options
+ * @param context
+ */
+// implementation signature
+async function parse(data, loaders, options, context) {
+    (0, worker_utils_1.assert)(!context || typeof context === 'object'); // parse no longer accepts final url
+    // Signature: parse(data, options, context | url)
+    // Uses registered loaders
+    if (loaders && !Array.isArray(loaders) && !(0, normalize_loader_1.isLoaderObject)(loaders)) {
+        context = undefined; // context not supported in short signature
+        options = loaders;
+        loaders = undefined;
+    }
+    data = await data; // Resolve any promise
+    options = options || {}; // Could be invalid...
+    // Extract a url for auto detection
+    const { url } = (0, resource_utils_1.getResourceUrlAndType)(data);
+    // Chooses a loader (and normalizes it)
+    // Also use any loaders in the context, new loaders take priority
+    const typedLoaders = loaders;
+    const candidateLoaders = (0, loader_context_1.getLoadersFromContext)(typedLoaders, context);
+    // todo hacky type cast
+    const loader = await (0, select_loader_1.selectLoader)(data, candidateLoaders, options);
+    // Note: if no loader was found, if so just return null
+    if (!loader) {
+        return null;
+    }
+    // Normalize options
+    options = (0, option_utils_1.normalizeOptions)(options, loader, candidateLoaders, url); // Could be invalid...
+    // Get a context (if already present, will be unchanged)
+    context = (0, loader_context_1.getLoaderContext)({ url, parse, loaders: candidateLoaders }, options, context);
+    return await parseWithLoader(loader, data, options, context);
 }
-
+exports.parse = parse;
+// TODO: support progress and abort
+// TODO - should accept loader.parseAsyncIterator and concatenate.
 async function parseWithLoader(loader, data, options, context) {
-  validateWorkerVersion(loader);
-  data = await getArrayBufferOrStringFromData(data, loader, options);
-
-  if (loader.parseTextSync && typeof data === 'string') {
-    options.dataType = 'text';
-    return loader.parseTextSync(data, options, context, loader);
-  }
-
-  if (canParseWithWorker(loader, options)) {
-    return await parseWithWorker(loader, data, options, context, parse);
-  }
-
-  if (loader.parseText && typeof data === 'string') {
-    return await loader.parseText(data, options, context, loader);
-  }
-
-  if (loader.parse) {
-    return await loader.parse(data, options, context, loader);
-  }
-
-  assert(!loader.parseSync);
-  throw new Error("".concat(loader.id, " loader - no parser found and worker is disabled"));
+    (0, worker_utils_1.validateWorkerVersion)(loader);
+    if ((0, is_type_1.isResponse)(data)) {
+        // Serialize to support passing the response to web worker
+        const response = data;
+        const { ok, redirected, status, statusText, type, url } = response;
+        const headers = Object.fromEntries(response.headers.entries());
+        context.response = { headers, ok, redirected, status, statusText, type, url };
+    }
+    data = await (0, get_data_1.getArrayBufferOrStringFromData)(data, loader, options);
+    // First check for synchronous text parser, wrap results in promises
+    if (loader.parseTextSync && typeof data === 'string') {
+        options.dataType = 'text';
+        return loader.parseTextSync(data, options, context, loader);
+    }
+    // If we have a workerUrl and the loader can parse the given options efficiently in a worker
+    if ((0, loader_utils_1.canParseWithWorker)(loader, options)) {
+        return await (0, loader_utils_1.parseWithWorker)(loader, data, options, context, parse);
+    }
+    // Check for asynchronous parser
+    if (loader.parseText && typeof data === 'string') {
+        return await loader.parseText(data, options, context, loader);
+    }
+    if (loader.parse) {
+        return await loader.parse(data, options, context, loader);
+    }
+    // This should not happen, all sync loaders should also offer `parse` function
+    (0, worker_utils_1.assert)(!loader.parseSync);
+    // TBD - If asynchronous parser not available, return null
+    throw new Error(`${loader.id} loader - no parser found and worker is disabled`);
 }
-//# sourceMappingURL=parse.js.map

package/dist/lib/api/register-loaders.d.ts

@@ -1,6 +1,6 @@
 import { Loader } from '@loaders.gl/loader-utils';
 /** Register a list of global loaders */
-export declare function registerLoaders(loaders: Loader[]): void;
+export declare function registerLoaders(loaders: Loader[] | Loader): void;
 export declare function getRegisteredLoaders(): Loader[];
 /** @deprecated For testing only  */
 export declare function _unregisterLoaders(): void;

package/dist/lib/api/register-loaders.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"register-loaders.d.ts","sourceRoot":"","sources":["../../../src/lib/api/register-loaders.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,MAAM,EAAC,MAAM,0BAA0B,CAAC;AAYhD,wCAAwC;AACxC,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,QAYhD;AAED,wBAAgB,oBAAoB,IAAI,MAAM,EAAE,CAE/C;AAED,oCAAoC;AACpC,wBAAgB,kBAAkB,SAGjC"}
+{"version":3,"file":"register-loaders.d.ts","sourceRoot":"","sources":["../../../src/lib/api/register-loaders.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,MAAM,EAAC,MAAM,0BAA0B,CAAC;AAYhD,wCAAwC;AACxC,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,MAAM,QAYzD;AAED,wBAAgB,oBAAoB,IAAI,MAAM,EAAE,CAE/C;AAED,oCAAoC;AACpC,wBAAgB,kBAAkB,SAGjC"}

package/dist/lib/api/register-loaders.js

@@ -1,29 +1,35 @@
-import { normalizeLoader } from '../loader-utils/normalize-loader';
-import { getGlobalLoaderState } from '../loader-utils/option-utils';
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._unregisterLoaders = exports.getRegisteredLoaders = exports.registerLoaders = void 0;
+const normalize_loader_1 = require("../loader-utils/normalize-loader");
+const option_utils_1 = require("../loader-utils/option-utils");
+// Store global registered loaders on the global object to increase chances of cross loaders-version interoperability
+// This use case is not reliable but can help when testing new versions of loaders.gl with existing frameworks
 const getGlobalLoaderRegistry = () => {
-  const state = getGlobalLoaderState();
-  state.loaderRegistry = state.loaderRegistry || [];
-  return state.loaderRegistry;
+    const state = (0, option_utils_1.getGlobalLoaderState)();
+    state.loaderRegistry = state.loaderRegistry || [];
+    return state.loaderRegistry;
 };
-
-export function registerLoaders(loaders) {
-  const loaderRegistry = getGlobalLoaderRegistry();
-  loaders = Array.isArray(loaders) ? loaders : [loaders];
-
-  for (const loader of loaders) {
-    const normalizedLoader = normalizeLoader(loader);
-
-    if (!loaderRegistry.find(registeredLoader => normalizedLoader === registeredLoader)) {
-      loaderRegistry.unshift(normalizedLoader);
+/** Register a list of global loaders */
+function registerLoaders(loaders) {
+    const loaderRegistry = getGlobalLoaderRegistry();
+    loaders = Array.isArray(loaders) ? loaders : [loaders];
+    for (const loader of loaders) {
+        const normalizedLoader = (0, normalize_loader_1.normalizeLoader)(loader);
+        if (!loaderRegistry.find((registeredLoader) => normalizedLoader === registeredLoader)) {
+            // add to the beginning of the loaderRegistry, so the last registeredLoader get picked
+            loaderRegistry.unshift(normalizedLoader);
+        }
     }
-  }
 }
-export function getRegisteredLoaders() {
-  return getGlobalLoaderRegistry();
+exports.registerLoaders = registerLoaders;
+function getRegisteredLoaders() {
+    return getGlobalLoaderRegistry();
 }
-export function _unregisterLoaders() {
-  const state = getGlobalLoaderState();
-  state.loaderRegistry = [];
+exports.getRegisteredLoaders = getRegisteredLoaders;
+/** @deprecated For testing only  */
+function _unregisterLoaders() {
+    const state = (0, option_utils_1.getGlobalLoaderState)();
+    state.loaderRegistry = [];
 }
-//# sourceMappingURL=register-loaders.js.map
+exports._unregisterLoaders = _unregisterLoaders;

package/dist/lib/api/save.js

@@ -1,11 +1,15 @@
-import { encode, encodeSync } from './encode';
-import { writeFile, writeFileSync } from '../fetch/write-file';
-export async function save(data, url, writer, options) {
-  const encodedData = await encode(data, writer, options);
-  return await writeFile(url, encodedData);
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveSync = exports.save = void 0;
+const encode_1 = require("./encode");
+const write_file_1 = require("../fetch/write-file");
+async function save(data, url, writer, options) {
+    const encodedData = await (0, encode_1.encode)(data, writer, options);
+    return await (0, write_file_1.writeFile)(url, encodedData);
 }
-export function saveSync(data, url, writer, options) {
-  const encodedData = encodeSync(data, writer, options);
-  return writeFileSync(url, encodedData);
+exports.save = save;
+function saveSync(data, url, writer, options) {
+    const encodedData = (0, encode_1.encodeSync)(data, writer, options);
+    return (0, write_file_1.writeFileSync)(url, encodedData);
 }
-//# sourceMappingURL=save.js.map
+exports.saveSync = saveSync;

package/dist/lib/api/select-loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"select-loader.d.ts","sourceRoot":"","sources":["../../../src/lib/api/select-loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,aAAa,EAAE,aAAa,EAAE,MAAM,EAAC,MAAM,0BAA0B,CAAC;AAanF;;;;;;;;GAQG;AACH,wBAAsB,YAAY,CAChC,IAAI,EAAE,QAAQ,GAAG,IAAI,GAAG,WAAW,GAAG,MAAM,EAC5C,OAAO,GAAE,MAAM,EAAE,GAAG,MAAW,EAC/B,OAAO,CAAC,EAAE,aAAa,EACvB,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAwBxB;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,QAAQ,GAAG,IAAI,GAAG,WAAW,GAAG,MAAM,EAC5C,OAAO,GAAE,MAAM,EAAE,GAAG,MAAW,EAC/B,OAAO,CAAC,EAAE,aAAa,EACvB,OAAO,CAAC,EAAE,aAAa,GACtB,MAAM,GAAG,IAAI,CAmCf"}
+{"version":3,"file":"select-loader.d.ts","sourceRoot":"","sources":["../../../src/lib/api/select-loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,aAAa,EAAE,aAAa,EAAE,MAAM,EAAC,MAAM,0BAA0B,CAAC;AAcnF;;;;;;;;GAQG;AACH,wBAAsB,YAAY,CAChC,IAAI,EAAE,QAAQ,GAAG,IAAI,GAAG,WAAW,GAAG,MAAM,EAC5C,OAAO,GAAE,MAAM,EAAE,GAAG,MAAW,EAC/B,OAAO,CAAC,EAAE,aAAa,EACvB,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAwBxB;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,QAAQ,GAAG,IAAI,GAAG,WAAW,GAAG,MAAM,EAC5C,OAAO,GAAE,MAAM,EAAE,GAAG,MAAW,EAC/B,OAAO,CAAC,EAAE,aAAa,EACvB,OAAO,CAAC,EAAE,aAAa,GACtB,MAAM,GAAG,IAAI,CAmCf"}