20352515932

Committed 18 Dec 2025 09:56PM UTC coverage: 35.115% (-28.4%) from 63.485%

Build # 20352515932

Build Type

push

github

Committed by

web-flow

Commit Message

feat(loader-utils): Export is-type helpers (#3258)

Coverage Stats

1188 of 1998 branches covered (59.46%)

Branch coverage included in aggregate %.

147 of 211 new or added lines in 13 files covered. (69.67%)

30011 existing lines in 424 files now uncovered.

37457 of 108056 relevant lines covered (34.66%)

0.79 hits per line

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

49.61

/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,
  SyncDataType,
  LoaderOptionsType,
  LoaderReturnType,
  LoaderArrayOptionsType,
  LoaderArrayReturnType,
  StrictLoaderOptions
} 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';

// OVERLOADS

/**
 * Parses `data` synchronously using the specified loader
 */
export function parseSync<
  LoaderT extends Loader,
  OptionsT extends LoaderOptions = LoaderOptionsType<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;
  }

  // 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
  );

  return parseWithLoaderSync(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);
  }

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

visgl / loaders.gl / 20352515932

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