24477111963

Committed 15 Apr 2026 08:37PM UTC coverage: 56.493% (+0.1%) from 56.365%

Build # 24477111963

Build Type

push

github

Committed by

web-flow

Commit Message

chore: Rename Source to SourceLoader (#3386)

Coverage Stats

9899 of 18977 branches covered (52.16%)

Branch coverage included in aggregate %.

91 of 204 new or added lines in 27 files covered. (44.61%)

4 existing lines in 2 files now uncovered.

20408 of 34670 relevant lines covered (58.86%)

4998.6 hits per line

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

80.43

/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 {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';

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

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

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

visgl / loaders.gl / 24477111963

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