• Home
  • Features
  • Pricing
  • Docs
  • Announcements
  • Sign In

visgl / loaders.gl / 24907303489

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

push

github

web-flow
feat: Dynamic import loaders (#3405)

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
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
}
STATUS · Troubleshooting · Open an Issue · Sales · Support · CAREERS · ENTERPRISE · START FREE · SCHEDULE DEMO
ANNOUNCEMENTS · TWITTER · TOS & SLA · Supported CI Services · What's a CI service? · Automated Testing

© 2026 Coveralls, Inc