24907303489

Committed 24 Apr 2026 07:12PM UTC coverage: 59.423% (+0.09%) from 59.334%

Build # 24907303489

Build Type

push

github

Committed by

web-flow

Commit Message

feat: Dynamic import loaders (#3405)

Coverage Stats

11252 of 20783 branches covered (54.14%)

Branch coverage included in aggregate %.

1164 of 1518 new or added lines in 244 files covered. (76.68%)

41 existing lines in 18 files now uncovered.

23432 of 37585 relevant lines covered (62.34%)

16317.58 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

76.36

/modules/core/src/lib/api/parse-sync.ts

// loaders.gl
// SPDX-License-Identifier: MIT
// Copyright (c) vis.gl contributors

import type {
  Loader,
  LoaderWithParser,
  LoaderOptions,
  LoaderContext,
  LoaderOptionsWithShape,
  SyncDataType,
  LoaderOptionsType,
  LoaderShapeType,
  LoaderReturnType,
  LoaderArrayOptionsType,
  LoaderArrayReturnType,
  StrictLoaderOptions
} from '@loaders.gl/loader-utils';
import {isSourceLoader} 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 {getResourceUrl} from '../utils/resource-utils';
import {getLoaderImplementationSync} from './load-loader';

// OVERLOADS

/**
 * Parses `data` synchronously using the specified loader
 */
export function parseSync<
  LoaderT extends Loader,
  OptionsT extends LoaderOptions = LoaderOptionsWithShape<
    LoaderOptionsType<LoaderT>,
    LoaderShapeType<LoaderT>
  >
>(
  data: SyncDataType,
  loader: LoaderT,
  options?: OptionsT,
  context?: LoaderContext
): LoaderReturnType<LoaderT>;

/**
 * Parses `data` synchronously by matching one of the supplied loaders
 */
export function parseSync<
  LoaderArrayT extends Loader[],
  OptionsT extends LoaderOptions = LoaderArrayOptionsType<LoaderArrayT>
>(
  data: SyncDataType,
  loaders: LoaderArrayT,
  options?: OptionsT,
  context?: LoaderContext
): LoaderArrayReturnType<LoaderArrayT>;

/**
 * Parses `data` synchronously by matching a pre=registered loader
 * @deprecated Loader registration is deprecated, use parseSync(data, loaders, options) instead
 */
export function parseSync(data: SyncDataType, options?: LoaderOptions): unknown;

/**
 * Parses `data` synchronously using a specified loader
 */
export function parseSync(
  data: SyncDataType,
  loaders?: Loader | Loader[] | LoaderOptions,
  options?: LoaderOptions,
  context?: LoaderContext
): unknown {
  // Signature: parseSync(data, options)
  // Uses registered loaders
  if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {
    context = undefined; // context not supported in short signature
    options = loaders as LoaderOptions;
    loaders = undefined;
  }

  options = options || {};

  // Chooses a loader (and normalizes it)
  // Also use any loaders in the context, new loaders take priority
  const typedLoaders = loaders as Loader | Loader[] | undefined;
  const candidateLoaders = getLoadersFromContext(typedLoaders, context);
  const loader = 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;
  }

  if (isSourceLoader(loader)) {
    throw new Error(
      `${loader.id} is a SourceLoader. Use load() to create a runtime source object instead of parseSync().`
    );
  }

  // Normalize options
  const strictOptions = normalizeOptions(options, loader, candidateLoaders as Loader[] | undefined);

  // Extract a url for auto detection
  const url = getResourceUrl(data);

  const parse = () => {
    throw new Error('parseSync called parse (which is async');
  };
  context = getLoaderContext(
    {url, _parseSync: parse, _parse: parse, loaders: loaders as Loader[]},
    strictOptions,
    context || null
  );

  const loaderWithParser = getLoaderImplementationSync(loader);
  return parseWithLoaderSync(
    loaderWithParser || (loader as LoaderWithParser),
    data,
    strictOptions,
    context
  );
}

// TODO - should accept loader.parseSync/parse and generate 1 chunk asyncIterator
function parseWithLoaderSync(
  loader: LoaderWithParser,
  data: SyncDataType,
  options: StrictLoaderOptions,
  context: LoaderContext
) {
  data = 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);
  }

  if (loader.preload) {
    throw new Error(
      `${loader.name} loader: 'parseSync' requires a parser-bearing loader. Import the loader implementation directly, or call preload(loader) before parseSync(). ${context.url || ''}`
    );
  }

  // 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 || ''
    }`
  );
}

1	// loaders.gl
2	// SPDX-License-Identifier: MIT
3	// Copyright (c) vis.gl contributors
4
5	import type {
6	Loader,
7	LoaderWithParser,
8	LoaderOptions,
9	LoaderContext,
10	LoaderOptionsWithShape,
11	SyncDataType,
12	LoaderOptionsType,
13	LoaderShapeType,
14	LoaderReturnType,
15	LoaderArrayOptionsType,
16	LoaderArrayReturnType,
17	StrictLoaderOptions
18	} from '@loaders.gl/loader-utils';
19	import {isSourceLoader} from '@loaders.gl/loader-utils';
20	import {selectLoaderSync} from './select-loader';
21	import {isLoaderObject} from '../loader-utils/normalize-loader';
22	import {normalizeOptions} from '../loader-utils/option-utils';
23	import {getArrayBufferOrStringFromDataSync} from '../loader-utils/get-data';
24	import {getLoaderContext, getLoadersFromContext} from '../loader-utils/loader-context';
25	import {getResourceUrl} from '../utils/resource-utils';
26	import {getLoaderImplementationSync} from './load-loader';
27
28	// OVERLOADS
29
30	/**
31	* Parses `data` synchronously using the specified loader
32	*/
33	export function parseSync<
34	LoaderT extends Loader,
35	OptionsT extends LoaderOptions = LoaderOptionsWithShape<
36	LoaderOptionsType<LoaderT>,
37	LoaderShapeType<LoaderT>
38	>
39	>(
40	data: SyncDataType,
41	loader: LoaderT,
42	options?: OptionsT,
43	context?: LoaderContext
44	): LoaderReturnType<LoaderT>;
45
46	/**
47	* Parses `data` synchronously by matching one of the supplied loaders
48	*/
49	export function parseSync<
50	LoaderArrayT extends Loader[],
51	OptionsT extends LoaderOptions = LoaderArrayOptionsType<LoaderArrayT>
52	>(
53	data: SyncDataType,
54	loaders: LoaderArrayT,
55	options?: OptionsT,
56	context?: LoaderContext
57	): LoaderArrayReturnType<LoaderArrayT>;
58
59	/**
60	* Parses `data` synchronously by matching a pre=registered loader
61	* @deprecated Loader registration is deprecated, use parseSync(data, loaders, options) instead
62	*/
63	export function parseSync(data: SyncDataType, options?: LoaderOptions): unknown;
64
65	/**
66	* Parses `data` synchronously using a specified loader
67	*/
68	export function parseSync(
69	data: SyncDataType,
70	loaders?: Loader \| Loader[] \| LoaderOptions,
71	options?: LoaderOptions,
72	context?: LoaderContext
73	): unknown {
74	// Signature: parseSync(data, options)
75	// Uses registered loaders
76	if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {	160,424!
77	context = undefined; // context not supported in short signature	×
78	options = loaders as LoaderOptions;	×
UNCOV 79	loaders = undefined;	×
80	}
81
82	options = options \|\| {};	160,424✔
83
84	// Chooses a loader (and normalizes it)
85	// Also use any loaders in the context, new loaders take priority
86	const typedLoaders = loaders as Loader \| Loader[] \| undefined;	160,424✔
87	const candidateLoaders = getLoadersFromContext(typedLoaders, context);	160,424✔
88	const loader = selectLoaderSync(data, candidateLoaders, options);	160,424✔
89	// Note: if nothrow option was set, it is possible that no loader was found, if so just return null
90	if (!loader) {	160,424!
UNCOV 91	return null;	×
92	}
93
94	if (isSourceLoader(loader)) {	160,424!
UNCOV 95	throw new Error(	×
96	`${loader.id} is a SourceLoader. Use load() to create a runtime source object instead of parseSync().`
97	);
98	}
99
100	// Normalize options
101	const strictOptions = normalizeOptions(options, loader, candidateLoaders as Loader[] \| undefined);	160,424✔
102
103	// Extract a url for auto detection
104	const url = getResourceUrl(data);	160,424✔
105
106	const parse = () => {	160,424✔
UNCOV 107	throw new Error('parseSync called parse (which is async');	×
108	};
109	context = getLoaderContext(	160,424✔
110	{url, _parseSync: parse, _parse: parse, loaders: loaders as Loader[]},
111	strictOptions,
112	context \|\| null	320,848✔
113	);
114
115	const loaderWithParser = getLoaderImplementationSync(loader);	160,424✔
116	return parseWithLoaderSync(	160,424✔
117	loaderWithParser \|\| (loader as LoaderWithParser),	160,440✔
118	data,
119	strictOptions,
120	context
121	);
122	}
123
124	// TODO - should accept loader.parseSync/parse and generate 1 chunk asyncIterator
125	function parseWithLoaderSync(
126	loader: LoaderWithParser,
127	data: SyncDataType,
128	options: StrictLoaderOptions,
129	context: LoaderContext
130	) {
131	data = getArrayBufferOrStringFromDataSync(data, loader, options);	160,424✔
132
133	if (loader.parseTextSync && typeof data === 'string') {	160,424✔
134	return loader.parseTextSync(data, options); // , context, loader);	160,272✔
135	}
136
137	if (loader.parseSync && data instanceof ArrayBuffer) {	152✔
138	return loader.parseSync(data, options, context); // , loader);	136✔
139	}
140
141	if (loader.preload) {	16!
142	throw new Error(	16✔
143	`${loader.name} loader: 'parseSync' requires a parser-bearing loader. Import the loader implementation directly, or call preload(loader) before parseSync(). ${context.url \|\| ''}`	28✔
144	);
145	}
146
147	// TBD - If synchronous parser not available, return null
UNCOV 148	throw new Error(	×
149	`${loader.name} loader: 'parseSync' not supported by this loader, use 'parse' instead. ${
150	context.url \|\| ''	×
151	}`
152	);
153	}

visgl / loaders.gl / 24907303489

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous