@loaders.gl/scientific 5.0.0-beta.1 → 5.0.0-beta.10
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +11 -4
- package/dist/hdf5/http-range-reader.d.ts.map +1 -1
- package/dist/hdf5/http-range-reader.js +2 -12
- package/dist/hdf5/http-range-reader.js.map +1 -1
- package/dist/hdf5/index.cjs +2 -11
- package/dist/hdf5/index.cjs.map +2 -2
- package/dist/index.cjs +136 -4152
- package/dist/index.cjs.map +4 -3
- package/dist/index.d.ts +14 -7
- package/dist/index.d.ts.map +1 -1
- package/dist/index.js +7 -4
- package/dist/index.js.map +1 -1
- package/dist/lib/parsers/parse-npy.d.ts +15 -0
- package/dist/lib/parsers/parse-npy.d.ts.map +1 -0
- package/dist/lib/parsers/parse-npy.js +81 -0
- package/dist/lib/parsers/parse-npy.js.map +1 -0
- package/dist/netcdf/bundled.cjs +47 -46
- package/dist/netcdf/index.cjs +47 -46
- package/dist/netcdf/index.cjs.map +3 -3
- package/dist/netcdf/index.d.ts +2 -1
- package/dist/netcdf/index.d.ts.map +1 -1
- package/dist/netcdf/index.js +2 -1
- package/dist/netcdf/index.js.map +1 -1
- package/dist/netcdf/netcdf-loader-with-parser.cjs +396 -2
- package/dist/netcdf/netcdf-loader-with-parser.d.ts +10 -0
- package/dist/netcdf/netcdf-loader-with-parser.d.ts.map +1 -1
- package/dist/netcdf/netcdf-loader-with-parser.js +3 -1
- package/dist/netcdf/netcdf-loader-with-parser.js.map +1 -1
- package/dist/netcdf/netcdf-loader.cjs +12 -9
- package/dist/netcdf/netcdf-loader.cjs.map +7 -0
- package/dist/netcdf/netcdf-loader.d.ts +10 -21
- package/dist/netcdf/netcdf-loader.d.ts.map +1 -1
- package/dist/netcdf/netcdf-loader.js +6 -3
- package/dist/netcdf/netcdf-loader.js.map +1 -1
- package/dist/netcdf/netcdf-source-loader.cjs +17 -31
- package/dist/netcdf/netcdf-source-loader.d.ts +2 -20
- package/dist/netcdf/netcdf-source-loader.d.ts.map +1 -1
- package/dist/netcdf/netcdf-source-loader.js +22 -20
- package/dist/netcdf/netcdf-source-loader.js.map +1 -1
- package/dist/netcdf/unbundled.cjs +47 -46
- package/dist/netcdf.dev.js +3095 -2654
- package/dist/netcdf.min.js +4 -4
- package/dist/npy-format.d.ts +12 -0
- package/dist/npy-format.d.ts.map +1 -0
- package/dist/npy-format.js +15 -0
- package/dist/npy-format.js.map +1 -0
- package/dist/{netcdf/netcdf-source-loader-types.cjs → npy-loader-types.cjs} +34 -35
- package/dist/npy-loader-types.cjs.map +7 -0
- package/dist/npy-loader-types.d.ts +53 -0
- package/dist/npy-loader-types.d.ts.map +1 -0
- package/dist/npy-loader-types.js +32 -0
- package/dist/npy-loader-types.js.map +1 -0
- package/dist/npy-loader.cjs +273 -0
- package/dist/npy-loader.cjs.map +6 -0
- package/dist/npy-loader.d.ts +27 -0
- package/dist/npy-loader.d.ts.map +1 -0
- package/dist/npy-loader.js +15 -0
- package/dist/npy-loader.js.map +1 -0
- package/dist/npy-worker.d.ts +2 -0
- package/dist/npy-worker.d.ts.map +1 -0
- package/dist/npy-worker.js +1285 -0
- package/dist/npy-worker.js.map +1 -0
- package/dist/nrrd/parse-nrrd.d.ts +22 -0
- package/dist/nrrd/parse-nrrd.d.ts.map +1 -0
- package/dist/nrrd/parse-nrrd.js +228 -0
- package/dist/nrrd/parse-nrrd.js.map +1 -0
- package/dist/nrrd-loader-types.cjs +58 -0
- package/dist/nrrd-loader-types.cjs.map +7 -0
- package/dist/nrrd-loader-types.d.ts +31 -0
- package/dist/nrrd-loader-types.d.ts.map +1 -0
- package/dist/nrrd-loader-types.js +25 -0
- package/dist/nrrd-loader-types.js.map +1 -0
- package/dist/nrrd-loader.cjs +252 -0
- package/dist/nrrd-loader.cjs.map +6 -0
- package/dist/nrrd-loader.d.ts +16 -0
- package/dist/nrrd-loader.d.ts.map +1 -0
- package/dist/nrrd-loader.js +8 -0
- package/dist/nrrd-loader.js.map +1 -0
- package/dist/vtk/index.cjs +26 -4117
- package/dist/vtk/index.cjs.map +3 -3
- package/dist/vtk/vtk-xml.js +4 -4
- package/dist/vtk/vtk-xml.js.map +1 -1
- package/dist/vtk/vtk.d.ts.map +1 -1
- package/dist/vtk/vtk.js +19 -1
- package/dist/vtk/vtk.js.map +1 -1
- package/dist/vtk-loader-types.cjs +58 -0
- package/dist/vtk-loader-types.cjs.map +7 -0
- package/dist/vtk-loader-types.d.ts +34 -0
- package/dist/vtk-loader-types.d.ts.map +1 -0
- package/dist/vtk-loader-types.js +25 -0
- package/dist/vtk-loader-types.js.map +1 -0
- package/dist/vtk-loader.cjs +384 -0
- package/dist/vtk-loader.cjs.map +6 -0
- package/dist/vtk-loader.d.ts +21 -0
- package/dist/vtk-loader.d.ts.map +1 -0
- package/dist/vtk-loader.js +21 -0
- package/dist/vtk-loader.js.map +1 -0
- package/dist/workers/npy-worker.d.ts +2 -0
- package/dist/workers/npy-worker.d.ts.map +1 -0
- package/dist/workers/npy-worker.js +7 -0
- package/dist/workers/npy-worker.js.map +1 -0
- package/dist/zarr/{geo-zarr-source-loader.d.ts → geo-zarr-loader.d.ts} +9 -9
- package/dist/zarr/geo-zarr-loader.d.ts.map +1 -0
- package/dist/zarr/{geo-zarr-source-loader.js → geo-zarr-loader.js} +167 -48
- package/dist/zarr/geo-zarr-loader.js.map +1 -0
- package/dist/zarr/index.cjs +221 -70
- package/dist/zarr/index.cjs.map +3 -3
- package/dist/zarr/index.d.ts +8 -8
- package/dist/zarr/index.d.ts.map +1 -1
- package/dist/zarr/index.js +4 -4
- package/dist/zarr/index.js.map +1 -1
- package/dist/zarr/lib/spatial-multiscales.d.ts +13 -2
- package/dist/zarr/lib/spatial-multiscales.d.ts.map +1 -1
- package/dist/zarr/lib/spatial-multiscales.js +94 -8
- package/dist/zarr/lib/spatial-multiscales.js.map +1 -1
- package/dist/zarr/{ome-zarr-source-loader.d.ts → ome-zarr-loader.d.ts} +9 -9
- package/dist/zarr/ome-zarr-loader.d.ts.map +1 -0
- package/dist/zarr/{ome-zarr-source-loader.js → ome-zarr-loader.js} +5 -5
- package/dist/zarr/ome-zarr-loader.js.map +1 -0
- package/dist/zarr/{spatial-data-source.d.ts → spatial-data-loader.d.ts} +11 -11
- package/dist/zarr/spatial-data-loader.d.ts.map +1 -0
- package/dist/zarr/{spatial-data-source.js → spatial-data-loader.js} +7 -7
- package/dist/zarr/spatial-data-loader.js.map +1 -0
- package/dist/zarr/{zarr-array-source.d.ts → zarr-array-loader.d.ts} +9 -9
- package/dist/zarr/{zarr-array-source.d.ts.map → zarr-array-loader.d.ts.map} +1 -1
- package/dist/zarr/{zarr-array-source.js → zarr-array-loader.js} +5 -5
- package/dist/zarr/{zarr-array-source.js.map → zarr-array-loader.js.map} +1 -1
- package/dist/zarr/zarr-loader-types.cjs +161 -0
- package/dist/zarr/zarr-loader-types.cjs.map +7 -0
- package/dist/zarr/zarr-loader-types.d.ts +32 -32
- package/dist/zarr/zarr-loader-types.d.ts.map +1 -1
- package/dist/zarr/zarr-loader-types.js +24 -24
- package/dist/zarr/zarr-loader-types.js.map +1 -1
- package/dist/zarr.dev.js +294 -80
- package/dist/zarr.min.js +40 -40
- package/package.json +54 -7
- package/src/hdf5/http-range-reader.ts +3 -11
- package/src/index.ts +27 -16
- package/src/lib/parsers/parse-npy.ts +123 -0
- package/src/netcdf/index.ts +2 -5
- package/src/netcdf/netcdf-loader-with-parser.ts +3 -1
- package/src/netcdf/netcdf-loader.ts +5 -3
- package/src/netcdf/netcdf-source-loader.ts +32 -24
- package/src/npy-format.ts +17 -0
- package/src/npy-loader-types.ts +47 -0
- package/src/npy-loader.ts +21 -0
- package/src/npy-worker.ts +6 -0
- package/src/nrrd/parse-nrrd.ts +267 -0
- package/src/nrrd-loader-types.ts +25 -0
- package/src/nrrd-loader.ts +7 -0
- package/src/vtk/vtk-xml.ts +4 -4
- package/src/vtk/vtk.ts +28 -1
- package/src/vtk-loader-types.ts +25 -0
- package/src/vtk-loader.ts +19 -0
- package/src/workers/npy-worker.ts +8 -0
- package/src/zarr/{geo-zarr-source-loader.ts → geo-zarr-loader.ts} +206 -55
- package/src/zarr/index.ts +17 -17
- package/src/zarr/lib/spatial-multiscales.ts +104 -8
- package/src/zarr/{ome-zarr-source-loader.ts → ome-zarr-loader.ts} +11 -11
- package/src/zarr/{spatial-data-source.ts → spatial-data-loader.ts} +16 -16
- package/src/zarr/{zarr-array-source.ts → zarr-array-loader.ts} +10 -10
- package/src/zarr/zarr-loader-types.ts +35 -35
- package/dist/netcdf/netcdf-source-loader-types.d.ts +0 -28
- package/dist/netcdf/netcdf-source-loader-types.d.ts.map +0 -1
- package/dist/netcdf/netcdf-source-loader-types.js +0 -32
- package/dist/netcdf/netcdf-source-loader-types.js.map +0 -1
- package/dist/zarr/geo-zarr-source-loader.d.ts.map +0 -1
- package/dist/zarr/geo-zarr-source-loader.js.map +0 -1
- package/dist/zarr/ome-zarr-source-loader.d.ts.map +0 -1
- package/dist/zarr/ome-zarr-source-loader.js.map +0 -1
- package/dist/zarr/spatial-data-source.d.ts.map +0 -1
- package/dist/zarr/spatial-data-source.js.map +0 -1
- package/src/netcdf/netcdf-source-loader-types.ts +0 -45
|
@@ -35,6 +35,9 @@ __export(netcdf_loader_with_parser_exports, {
|
|
|
35
35
|
});
|
|
36
36
|
module.exports = __toCommonJS(netcdf_loader_with_parser_exports);
|
|
37
37
|
|
|
38
|
+
// src/netcdf/netcdf-source-loader.ts
|
|
39
|
+
var import_loader_utils = require("@loaders.gl/core/loader-utils");
|
|
40
|
+
|
|
38
41
|
// src/netcdf/iobuffer/iobuffer.ts
|
|
39
42
|
var DEFAULT_BYTE_LENGTH = 1024 * 8;
|
|
40
43
|
var IOBuffer = class _IOBuffer {
|
|
@@ -922,6 +925,392 @@ var NetCDFReader = class {
|
|
|
922
925
|
}
|
|
923
926
|
};
|
|
924
927
|
|
|
928
|
+
// src/netcdf/netcdf-source-loader.ts
|
|
929
|
+
var NetCDFSource = class _NetCDFSource extends import_loader_utils.DataSource {
|
|
930
|
+
static HEADER_RANGE_SIZE = 64 * 1024;
|
|
931
|
+
static MAX_HEADER_RANGE_SIZE = 4 * 1024 * 1024;
|
|
932
|
+
headerPromise = null;
|
|
933
|
+
/** Capabilities of the NetCDF variable and dimension-slice executor. */
|
|
934
|
+
rasterQueryCapabilities = Object.freeze({
|
|
935
|
+
bounds: "unsupported",
|
|
936
|
+
level: "unsupported",
|
|
937
|
+
variables: "pushdown",
|
|
938
|
+
slices: "residual",
|
|
939
|
+
streaming: false,
|
|
940
|
+
cancellation: true
|
|
941
|
+
});
|
|
942
|
+
/** Creates a source over a NetCDF URL or Blob. */
|
|
943
|
+
constructor(data, options = {}) {
|
|
944
|
+
super(data, options);
|
|
945
|
+
}
|
|
946
|
+
/** Discovers variables and dimensions without decoding data arrays. */
|
|
947
|
+
async getQueryMetadata(options = {}) {
|
|
948
|
+
throwIfAborted(options.signal);
|
|
949
|
+
const { header, byteLength } = await this.getHeader(options.signal);
|
|
950
|
+
throwIfAborted(options.signal);
|
|
951
|
+
const fields = header.variables.map((variable) => createVariableField(variable, header));
|
|
952
|
+
const schema = { fields, metadata: createDimensionMetadata(header) };
|
|
953
|
+
return (0, import_loader_utils.createScanQueryMetadata)({
|
|
954
|
+
sourceType: "netcdf",
|
|
955
|
+
queryType: "raster",
|
|
956
|
+
execution: { status: "supported", method: "getRaster" },
|
|
957
|
+
name: typeof this.data === "string" ? this.data.split("/").pop() : void 0,
|
|
958
|
+
schema,
|
|
959
|
+
capabilities: {
|
|
960
|
+
bounds: "unsupported",
|
|
961
|
+
levelOfDetail: "unsupported",
|
|
962
|
+
raster: this.rasterQueryCapabilities
|
|
963
|
+
},
|
|
964
|
+
statistics: {
|
|
965
|
+
byteLength,
|
|
966
|
+
rowCount: header.recordDimension.length || void 0
|
|
967
|
+
}
|
|
968
|
+
});
|
|
969
|
+
}
|
|
970
|
+
/**
|
|
971
|
+
* Reads selected numeric variables and applies named dimension slices.
|
|
972
|
+
*
|
|
973
|
+
* Multiple variables must retain the same shape and numeric type so they can be returned as
|
|
974
|
+
* ordinary raster bands. Leading dimensions are folded into height and the final dimension is
|
|
975
|
+
* exposed as width; the original dimension names and shape remain in result metadata.
|
|
976
|
+
*/
|
|
977
|
+
async getRaster(options = {}) {
|
|
978
|
+
(0, import_loader_utils.validateRasterQueryOptions)(options);
|
|
979
|
+
validateNetCDFUnsupportedRasterOptions(options);
|
|
980
|
+
throwIfAborted(options.signal);
|
|
981
|
+
const reader = await this.loadReader(options.signal);
|
|
982
|
+
throwIfAborted(options.signal);
|
|
983
|
+
validateNetCDFSliceNames(reader.header, options.slices);
|
|
984
|
+
const variables = selectNetCDFVariables(reader.header, options.variables);
|
|
985
|
+
const results = variables.map((variable) => {
|
|
986
|
+
throwIfAborted(options.signal);
|
|
987
|
+
const dimensionNames = variable.dimensions.map(
|
|
988
|
+
(dimensionId) => reader.header.dimensions[dimensionId]?.name || `dimension_${dimensionId}`
|
|
989
|
+
);
|
|
990
|
+
const dimensionSizes = variable.dimensions.map(
|
|
991
|
+
(dimensionId) => getDimensionSize(reader.header, dimensionId)
|
|
992
|
+
);
|
|
993
|
+
const values = flattenNetCDFValues(reader.getDataVariable(variable));
|
|
994
|
+
const selection = selectNetCDFValues(
|
|
995
|
+
values,
|
|
996
|
+
dimensionNames,
|
|
997
|
+
dimensionSizes,
|
|
998
|
+
options.slices || {},
|
|
999
|
+
options.signal
|
|
1000
|
+
);
|
|
1001
|
+
const dtype = getNetCDFRasterDataType(variable.type);
|
|
1002
|
+
return {
|
|
1003
|
+
variable,
|
|
1004
|
+
dimensionNames: selection.dimensionNames,
|
|
1005
|
+
shape: selection.shape,
|
|
1006
|
+
data: createNetCDFTypedArray(selection.values, dtype),
|
|
1007
|
+
dtype
|
|
1008
|
+
};
|
|
1009
|
+
});
|
|
1010
|
+
const reference = results[0];
|
|
1011
|
+
for (const result of results.slice(1)) {
|
|
1012
|
+
if (result.dtype !== reference.dtype || !arraysEqual(result.shape, reference.shape)) {
|
|
1013
|
+
throw new Error(
|
|
1014
|
+
"NetCDF raster variables must retain the same shape and numeric type after slicing."
|
|
1015
|
+
);
|
|
1016
|
+
}
|
|
1017
|
+
}
|
|
1018
|
+
const width = reference.shape.at(-1) ?? 1;
|
|
1019
|
+
const height = reference.shape.length < 2 ? 1 : reference.shape.slice(0, -1).reduce((product, size) => product * size, 1);
|
|
1020
|
+
const noData = getNetCDFNoDataValue(reference.variable);
|
|
1021
|
+
return {
|
|
1022
|
+
data: results.length === 1 ? reference.data : results.map((result) => result.data),
|
|
1023
|
+
width,
|
|
1024
|
+
height,
|
|
1025
|
+
bandCount: results.length,
|
|
1026
|
+
dtype: reference.dtype,
|
|
1027
|
+
interleaved: false,
|
|
1028
|
+
noData,
|
|
1029
|
+
metadata: {
|
|
1030
|
+
variables: results.map((result) => result.variable.name),
|
|
1031
|
+
dimensions: reference.dimensionNames,
|
|
1032
|
+
shape: reference.shape,
|
|
1033
|
+
slices: { ...options.slices }
|
|
1034
|
+
}
|
|
1035
|
+
};
|
|
1036
|
+
}
|
|
1037
|
+
/** Loads a complete NetCDF reader for selected-variable execution. */
|
|
1038
|
+
async loadReader(signal) {
|
|
1039
|
+
let arrayBuffer;
|
|
1040
|
+
if (typeof this.data === "string") {
|
|
1041
|
+
const response = await this.fetch(this.url, { signal });
|
|
1042
|
+
if (!response.ok) throw new Error(`NetCDF request failed with status ${response.status}.`);
|
|
1043
|
+
arrayBuffer = await response.arrayBuffer();
|
|
1044
|
+
} else {
|
|
1045
|
+
arrayBuffer = await this.data.arrayBuffer();
|
|
1046
|
+
}
|
|
1047
|
+
throwIfAborted(signal);
|
|
1048
|
+
return new NetCDFReader(arrayBuffer);
|
|
1049
|
+
}
|
|
1050
|
+
/** Reads and caches the NetCDF header, preserving abort behavior for each caller. */
|
|
1051
|
+
async getHeader(signal) {
|
|
1052
|
+
throwIfAborted(signal);
|
|
1053
|
+
if (!this.headerPromise) {
|
|
1054
|
+
this.headerPromise = this.loadHeader().catch((error) => {
|
|
1055
|
+
this.headerPromise = null;
|
|
1056
|
+
throw error;
|
|
1057
|
+
});
|
|
1058
|
+
}
|
|
1059
|
+
const result = await this.headerPromise;
|
|
1060
|
+
throwIfAborted(signal);
|
|
1061
|
+
return result;
|
|
1062
|
+
}
|
|
1063
|
+
/** Loads enough leading bytes to parse a remote header, growing ranges when required. */
|
|
1064
|
+
async loadHeader() {
|
|
1065
|
+
if (typeof this.data !== "string") {
|
|
1066
|
+
const arrayBuffer2 = await this.data.arrayBuffer();
|
|
1067
|
+
return { header: new NetCDFReader(arrayBuffer2).header, byteLength: arrayBuffer2.byteLength };
|
|
1068
|
+
}
|
|
1069
|
+
let rangeSize = _NetCDFSource.HEADER_RANGE_SIZE;
|
|
1070
|
+
let response = null;
|
|
1071
|
+
let arrayBuffer = null;
|
|
1072
|
+
let lastError;
|
|
1073
|
+
while (rangeSize <= _NetCDFSource.MAX_HEADER_RANGE_SIZE) {
|
|
1074
|
+
response = await this.fetch(this.url, {
|
|
1075
|
+
headers: { Range: `bytes=0-${rangeSize - 1}` }
|
|
1076
|
+
});
|
|
1077
|
+
if (!response.ok) throw new Error(`NetCDF request failed with status ${response.status}.`);
|
|
1078
|
+
arrayBuffer = await response.arrayBuffer();
|
|
1079
|
+
let byteLength = getResponseByteLength(response, arrayBuffer.byteLength);
|
|
1080
|
+
if (response.status === 206 && !response.headers.has("Content-Range") && arrayBuffer.byteLength === rangeSize) {
|
|
1081
|
+
const metadata = await this.fetch(this.url, { method: "HEAD" });
|
|
1082
|
+
const value = metadata.headers.get("Content-Length");
|
|
1083
|
+
await metadata.body?.cancel();
|
|
1084
|
+
if (metadata.status !== 200 || !value || !/^\d+$/.test(value) || !Number.isSafeInteger(Number(value)) || Number(value) < arrayBuffer.byteLength) {
|
|
1085
|
+
throw new Error(
|
|
1086
|
+
"NetCDF file size unavailable: expose Content-Range or provide HEAD Content-Length"
|
|
1087
|
+
);
|
|
1088
|
+
}
|
|
1089
|
+
byteLength = Number(value);
|
|
1090
|
+
}
|
|
1091
|
+
try {
|
|
1092
|
+
return { header: new NetCDFReader(arrayBuffer).header, byteLength };
|
|
1093
|
+
} catch (error) {
|
|
1094
|
+
lastError = error;
|
|
1095
|
+
if (response.status !== 206 || arrayBuffer.byteLength < rangeSize) throw error;
|
|
1096
|
+
rangeSize *= 2;
|
|
1097
|
+
}
|
|
1098
|
+
}
|
|
1099
|
+
throw lastError || new Error("NetCDF header exceeds the maximum metadata range.");
|
|
1100
|
+
}
|
|
1101
|
+
};
|
|
1102
|
+
function createNetCDFSource(data, options) {
|
|
1103
|
+
return new NetCDFSource(data, options);
|
|
1104
|
+
}
|
|
1105
|
+
function getNetCDFDataType(type) {
|
|
1106
|
+
switch (type.toLowerCase()) {
|
|
1107
|
+
case "byte":
|
|
1108
|
+
return "int8";
|
|
1109
|
+
case "ubyte":
|
|
1110
|
+
return "uint8";
|
|
1111
|
+
case "short":
|
|
1112
|
+
return "int16";
|
|
1113
|
+
case "ushort":
|
|
1114
|
+
return "uint16";
|
|
1115
|
+
case "int":
|
|
1116
|
+
return "int32";
|
|
1117
|
+
case "uint":
|
|
1118
|
+
return "uint32";
|
|
1119
|
+
case "int64":
|
|
1120
|
+
return "int64";
|
|
1121
|
+
case "uint64":
|
|
1122
|
+
return "uint64";
|
|
1123
|
+
case "float":
|
|
1124
|
+
return "float32";
|
|
1125
|
+
case "double":
|
|
1126
|
+
return "float64";
|
|
1127
|
+
case "char":
|
|
1128
|
+
case "string":
|
|
1129
|
+
return "utf8";
|
|
1130
|
+
default:
|
|
1131
|
+
return "binary";
|
|
1132
|
+
}
|
|
1133
|
+
}
|
|
1134
|
+
function validateNetCDFUnsupportedRasterOptions(options) {
|
|
1135
|
+
if (options.bounds) throw new Error("NetCDF raster bounds are not supported.");
|
|
1136
|
+
if (options.level !== void 0) throw new Error("NetCDF raster levels are not supported.");
|
|
1137
|
+
if (options.width !== void 0 || options.height !== void 0) {
|
|
1138
|
+
throw new Error("NetCDF raster resampling is not supported.");
|
|
1139
|
+
}
|
|
1140
|
+
if (options.channels?.length) {
|
|
1141
|
+
throw new Error("NetCDF uses named variables instead of numeric channels.");
|
|
1142
|
+
}
|
|
1143
|
+
}
|
|
1144
|
+
function selectNetCDFVariables(header, requestedVariableNames) {
|
|
1145
|
+
const defaultVariable = header.variables.find(
|
|
1146
|
+
(variable) => variable.dimensions.length > 0 && isNetCDFRasterDataType(variable.type)
|
|
1147
|
+
);
|
|
1148
|
+
const variableNames = requestedVariableNames?.length ? [...requestedVariableNames] : defaultVariable ? [defaultVariable.name] : [];
|
|
1149
|
+
if (variableNames.length === 0) {
|
|
1150
|
+
throw new Error("NetCDF contains no numeric variables that can be read as raster data.");
|
|
1151
|
+
}
|
|
1152
|
+
if (new Set(variableNames).size !== variableNames.length) {
|
|
1153
|
+
throw new Error("NetCDF raster variables must not contain duplicates.");
|
|
1154
|
+
}
|
|
1155
|
+
return variableNames.map((variableName) => {
|
|
1156
|
+
const variable = header.variables.find((candidate) => candidate.name === variableName);
|
|
1157
|
+
if (!variable) throw new Error(`NetCDF variable not found: ${variableName}`);
|
|
1158
|
+
getNetCDFRasterDataType(variable.type);
|
|
1159
|
+
return variable;
|
|
1160
|
+
});
|
|
1161
|
+
}
|
|
1162
|
+
function validateNetCDFSliceNames(header, slices) {
|
|
1163
|
+
const dimensionNames = new Set(header.dimensions.map((dimension) => dimension.name));
|
|
1164
|
+
for (const dimensionName of Object.keys(slices || {})) {
|
|
1165
|
+
if (!dimensionNames.has(dimensionName)) {
|
|
1166
|
+
throw new Error(`NetCDF dimension not found: ${dimensionName}`);
|
|
1167
|
+
}
|
|
1168
|
+
}
|
|
1169
|
+
}
|
|
1170
|
+
function selectNetCDFValues(values, dimensionNames, dimensionSizes, slices, signal) {
|
|
1171
|
+
const selectors = dimensionNames.map((dimensionName, dimensionIndex) => {
|
|
1172
|
+
const size = dimensionSizes[dimensionIndex];
|
|
1173
|
+
const slice = slices[dimensionName];
|
|
1174
|
+
if (slice === void 0) return { start: 0, stop: size, remove: false };
|
|
1175
|
+
if (typeof slice !== "number") {
|
|
1176
|
+
const [start, stop] = slice;
|
|
1177
|
+
if (!Number.isSafeInteger(start) || !Number.isSafeInteger(stop) || start < 0 || stop < start || stop > size) {
|
|
1178
|
+
throw new Error(
|
|
1179
|
+
`NetCDF slice ${dimensionName} must be a valid half-open range within 0..${size}.`
|
|
1180
|
+
);
|
|
1181
|
+
}
|
|
1182
|
+
return { start, stop, remove: false };
|
|
1183
|
+
}
|
|
1184
|
+
if (!Number.isSafeInteger(slice) || slice < 0 || slice >= size) {
|
|
1185
|
+
throw new Error(`NetCDF slice ${dimensionName} must be an index within 0..${size - 1}.`);
|
|
1186
|
+
}
|
|
1187
|
+
return { start: slice, stop: slice + 1, remove: true };
|
|
1188
|
+
});
|
|
1189
|
+
const strides = dimensionSizes.map(
|
|
1190
|
+
(_, dimensionIndex) => dimensionSizes.slice(dimensionIndex + 1).reduce((product, dimensionSize) => product * dimensionSize, 1)
|
|
1191
|
+
);
|
|
1192
|
+
const selectedValues = [];
|
|
1193
|
+
const visitDimension = (dimensionIndex, flatOffset) => {
|
|
1194
|
+
throwIfAborted(signal);
|
|
1195
|
+
if (dimensionIndex === selectors.length) {
|
|
1196
|
+
const value = values[flatOffset];
|
|
1197
|
+
if (typeof value !== "number") {
|
|
1198
|
+
throw new Error("NetCDF raster variables must contain numeric values.");
|
|
1199
|
+
}
|
|
1200
|
+
selectedValues.push(value);
|
|
1201
|
+
return;
|
|
1202
|
+
}
|
|
1203
|
+
const selector = selectors[dimensionIndex];
|
|
1204
|
+
for (let index = selector.start; index < selector.stop; index++) {
|
|
1205
|
+
visitDimension(dimensionIndex + 1, flatOffset + index * strides[dimensionIndex]);
|
|
1206
|
+
}
|
|
1207
|
+
};
|
|
1208
|
+
visitDimension(0, 0);
|
|
1209
|
+
return {
|
|
1210
|
+
values: selectedValues,
|
|
1211
|
+
dimensionNames: dimensionNames.filter((_, index) => !selectors[index].remove),
|
|
1212
|
+
shape: selectors.map((selector) => selector.stop - selector.start).filter((_, index) => !selectors[index].remove)
|
|
1213
|
+
};
|
|
1214
|
+
}
|
|
1215
|
+
function flattenNetCDFValues(values) {
|
|
1216
|
+
if (Array.isArray(values)) return values.flatMap(flattenNetCDFValues);
|
|
1217
|
+
if (ArrayBuffer.isView(values)) {
|
|
1218
|
+
return Array.from(values);
|
|
1219
|
+
}
|
|
1220
|
+
return [values];
|
|
1221
|
+
}
|
|
1222
|
+
function isNetCDFRasterDataType(type) {
|
|
1223
|
+
try {
|
|
1224
|
+
getNetCDFRasterDataType(type);
|
|
1225
|
+
return true;
|
|
1226
|
+
} catch {
|
|
1227
|
+
return false;
|
|
1228
|
+
}
|
|
1229
|
+
}
|
|
1230
|
+
function getNetCDFRasterDataType(type) {
|
|
1231
|
+
switch (type.toLowerCase()) {
|
|
1232
|
+
case "byte":
|
|
1233
|
+
return "int8";
|
|
1234
|
+
case "ubyte":
|
|
1235
|
+
return "uint8";
|
|
1236
|
+
case "short":
|
|
1237
|
+
return "int16";
|
|
1238
|
+
case "ushort":
|
|
1239
|
+
return "uint16";
|
|
1240
|
+
case "int":
|
|
1241
|
+
return "int32";
|
|
1242
|
+
case "uint":
|
|
1243
|
+
return "uint32";
|
|
1244
|
+
case "float":
|
|
1245
|
+
return "float32";
|
|
1246
|
+
case "double":
|
|
1247
|
+
return "float64";
|
|
1248
|
+
default:
|
|
1249
|
+
throw new Error(`NetCDF variable type is not supported as raster data: ${type}`);
|
|
1250
|
+
}
|
|
1251
|
+
}
|
|
1252
|
+
function createNetCDFTypedArray(values, dtype) {
|
|
1253
|
+
switch (dtype) {
|
|
1254
|
+
case "int8":
|
|
1255
|
+
return Int8Array.from(values);
|
|
1256
|
+
case "uint8":
|
|
1257
|
+
return Uint8Array.from(values);
|
|
1258
|
+
case "int16":
|
|
1259
|
+
return Int16Array.from(values);
|
|
1260
|
+
case "uint16":
|
|
1261
|
+
return Uint16Array.from(values);
|
|
1262
|
+
case "int32":
|
|
1263
|
+
return Int32Array.from(values);
|
|
1264
|
+
case "uint32":
|
|
1265
|
+
return Uint32Array.from(values);
|
|
1266
|
+
case "float32":
|
|
1267
|
+
return Float32Array.from(values);
|
|
1268
|
+
case "float64":
|
|
1269
|
+
return Float64Array.from(values);
|
|
1270
|
+
}
|
|
1271
|
+
}
|
|
1272
|
+
function getNetCDFNoDataValue(variable) {
|
|
1273
|
+
const attribute = variable.attributes.find(
|
|
1274
|
+
(candidate) => candidate.name === "_FillValue" || candidate.name === "missing_value"
|
|
1275
|
+
);
|
|
1276
|
+
const value = Number(attribute?.value);
|
|
1277
|
+
return attribute && Number.isFinite(value) ? value : null;
|
|
1278
|
+
}
|
|
1279
|
+
function arraysEqual(left, right) {
|
|
1280
|
+
return left.length === right.length && left.every((value, index) => value === right[index]);
|
|
1281
|
+
}
|
|
1282
|
+
function createVariableField(variable, header) {
|
|
1283
|
+
const dimensions = variable.dimensions.map((dimensionId) => header.dimensions[dimensionId]).filter(Boolean).map(
|
|
1284
|
+
(dimension, index) => `${dimension.name}[${getDimensionSize(header, variable.dimensions[index])}]`
|
|
1285
|
+
).join(",");
|
|
1286
|
+
const metadata = { dimensions };
|
|
1287
|
+
for (const attribute of variable.attributes) {
|
|
1288
|
+
metadata[attribute.name] = String(attribute.value);
|
|
1289
|
+
}
|
|
1290
|
+
return { name: variable.name, type: getNetCDFDataType(variable.type), nullable: true, metadata };
|
|
1291
|
+
}
|
|
1292
|
+
function createDimensionMetadata(header) {
|
|
1293
|
+
const metadata = {};
|
|
1294
|
+
for (const [dimensionId, dimension] of header.dimensions.entries()) {
|
|
1295
|
+
metadata[`dimension:${dimension.name}`] = String(getDimensionSize(header, dimensionId));
|
|
1296
|
+
}
|
|
1297
|
+
return metadata;
|
|
1298
|
+
}
|
|
1299
|
+
function getDimensionSize(header, dimensionId) {
|
|
1300
|
+
const dimension = header.dimensions[dimensionId];
|
|
1301
|
+
return dimensionId === header.recordDimension.id ? header.recordDimension.length : dimension?.size || 0;
|
|
1302
|
+
}
|
|
1303
|
+
function getResponseByteLength(response, fallback) {
|
|
1304
|
+
const contentRange = response.headers.get("content-range");
|
|
1305
|
+
const total = contentRange?.match(/\/([0-9]+)$/)?.[1];
|
|
1306
|
+
return Number(total || response.headers.get("content-length") || fallback);
|
|
1307
|
+
}
|
|
1308
|
+
function throwIfAborted(signal) {
|
|
1309
|
+
if (signal?.aborted) {
|
|
1310
|
+
throw new DOMException("The operation was aborted", "AbortError");
|
|
1311
|
+
}
|
|
1312
|
+
}
|
|
1313
|
+
|
|
925
1314
|
// src/netcdf/netcdf-format.ts
|
|
926
1315
|
var NetCDFFormat = {
|
|
927
1316
|
name: "NetCDF",
|
|
@@ -941,6 +1330,11 @@ async function preload() {
|
|
|
941
1330
|
return NetCDFLoaderWithParser2;
|
|
942
1331
|
}
|
|
943
1332
|
var NetCDFLoader = {
|
|
1333
|
+
/** Matches input for source selection. */
|
|
1334
|
+
testURL: (url) => /\.(?:cdf|nc)(?:$|[?#])/i.test(url),
|
|
1335
|
+
fromUrl: true,
|
|
1336
|
+
fromBlob: true,
|
|
1337
|
+
type: "netcdf",
|
|
944
1338
|
...NetCDFFormat,
|
|
945
1339
|
dataType: null,
|
|
946
1340
|
batchType: null,
|
|
@@ -963,15 +1357,15 @@ var NetCDFLoader = {
|
|
|
963
1357
|
},
|
|
964
1358
|
preload
|
|
965
1359
|
};
|
|
966
|
-
var NetCDFWorkerLoader = NetCDFLoader;
|
|
967
1360
|
|
|
968
1361
|
// src/netcdf/netcdf-loader-with-parser.ts
|
|
969
|
-
var { preload: _NetCDFWorkerLoaderPreload, ...NetCDFWorkerLoaderMetadataWithoutPreload } =
|
|
1362
|
+
var { preload: _NetCDFWorkerLoaderPreload, ...NetCDFWorkerLoaderMetadataWithoutPreload } = NetCDFLoader;
|
|
970
1363
|
var { preload: _NetCDFLoaderPreload, ...NetCDFLoaderMetadataWithoutPreload } = NetCDFLoader;
|
|
971
1364
|
var NetCDFWorkerLoaderWithParser = {
|
|
972
1365
|
...NetCDFWorkerLoaderMetadataWithoutPreload
|
|
973
1366
|
};
|
|
974
1367
|
var NetCDFLoaderWithParser = {
|
|
1368
|
+
createDataSourceSync: createNetCDFSource,
|
|
975
1369
|
...NetCDFLoaderMetadataWithoutPreload,
|
|
976
1370
|
parse: async (arrayBuffer, options) => parseNetCDF(arrayBuffer, options)
|
|
977
1371
|
};
|
|
@@ -1,3 +1,4 @@
|
|
|
1
|
+
import { createNetCDFSource } from "./netcdf-source-loader.js";
|
|
1
2
|
import type { LoaderOptions } from '@loaders.gl/core/loader-utils';
|
|
2
3
|
import type { NetCDFHeader } from "./netcdfjs/netcdf-types.js";
|
|
3
4
|
export type NetCDF = {
|
|
@@ -33,6 +34,10 @@ export declare const NetCDFWorkerLoaderWithParser: {
|
|
|
33
34
|
};
|
|
34
35
|
readonly encoding: "binary";
|
|
35
36
|
readonly format: "netcdf";
|
|
37
|
+
readonly testURL: (url: string) => boolean;
|
|
38
|
+
readonly fromUrl: true;
|
|
39
|
+
readonly fromBlob: true;
|
|
40
|
+
readonly type: "netcdf";
|
|
36
41
|
};
|
|
37
42
|
/**
|
|
38
43
|
* Loader for the NetCDF format
|
|
@@ -56,5 +61,10 @@ export declare const NetCDFLoaderWithParser: {
|
|
|
56
61
|
};
|
|
57
62
|
readonly encoding: "binary";
|
|
58
63
|
readonly format: "netcdf";
|
|
64
|
+
readonly testURL: (url: string) => boolean;
|
|
65
|
+
readonly fromUrl: true;
|
|
66
|
+
readonly fromBlob: true;
|
|
67
|
+
readonly type: "netcdf";
|
|
68
|
+
readonly createDataSourceSync: typeof createNetCDFSource;
|
|
59
69
|
};
|
|
60
70
|
//# sourceMappingURL=netcdf-loader-with-parser.d.ts.map
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"netcdf-loader-with-parser.d.ts","sourceRoot":"","sources":["../../src/netcdf/netcdf-loader-with-parser.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAA2B,aAAa,EAAC,MAAM,+BAA+B,CAAC;AAC3F,OAAO,KAAK,EAAC,YAAY,EAAC,mCAAgC;AAS1D,MAAM,MAAM,MAAM,GAAG;IACnB,UAAU,EAAE,YAAY,CAAC;IACzB,IAAI,EAAE;QAAC,CAAC,YAAY,EAAE,MAAM,GAAG,GAAG,EAAE,EAAE,CAAA;KAAC,CAAC;CACzC,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG,aAAa,GAAG;IAChD,MAAM,CAAC,EAAE;QACP,QAAQ,CAAC,EAAE,OAAO,CAAC;QACnB,aAAa,CAAC,EAAE,OAAO,CAAC;KACzB,CAAC;CACH,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,4BAA4B
|
|
1
|
+
{"version":3,"file":"netcdf-loader-with-parser.d.ts","sourceRoot":"","sources":["../../src/netcdf/netcdf-loader-with-parser.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,kBAAkB,EAAC,kCAA+B;AAC1D,OAAO,KAAK,EAA2B,aAAa,EAAC,MAAM,+BAA+B,CAAC;AAC3F,OAAO,KAAK,EAAC,YAAY,EAAC,mCAAgC;AAS1D,MAAM,MAAM,MAAM,GAAG;IACnB,UAAU,EAAE,YAAY,CAAC;IACzB,IAAI,EAAE;QAAC,CAAC,YAAY,EAAE,MAAM,GAAG,GAAG,EAAE,EAAE,CAAA;KAAC,CAAC;CACzC,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG,aAAa,GAAG;IAChD,MAAM,CAAC,EAAE;QACP,QAAQ,CAAC,EAAE,OAAO,CAAC;QACnB,aAAa,CAAC,EAAE,OAAO,CAAC;KACzB,CAAC;CACH,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;CAEsB,CAAC;AAEhE;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;CAIsC,CAAC"}
|
|
@@ -1,8 +1,9 @@
|
|
|
1
1
|
// loaders.gl
|
|
2
2
|
// SPDX-License-Identifier: MIT
|
|
3
3
|
// Copyright (c) vis.gl contributors
|
|
4
|
+
import { createNetCDFSource } from "./netcdf-source-loader.js";
|
|
4
5
|
import { NetCDFReader } from "./netcdfjs/netcdf-reader.js";
|
|
5
|
-
import {
|
|
6
|
+
import { NetCDFLoader as NetCDFWorkerLoaderMetadata } from "./netcdf-loader.js";
|
|
6
7
|
import { NetCDFLoader as NetCDFLoaderMetadata } from "./netcdf-loader.js";
|
|
7
8
|
const { preload: _NetCDFWorkerLoaderPreload, ...NetCDFWorkerLoaderMetadataWithoutPreload } = NetCDFWorkerLoaderMetadata;
|
|
8
9
|
const { preload: _NetCDFLoaderPreload, ...NetCDFLoaderMetadataWithoutPreload } = NetCDFLoaderMetadata;
|
|
@@ -16,6 +17,7 @@ export const NetCDFWorkerLoaderWithParser = {
|
|
|
16
17
|
* Loader for the NetCDF format
|
|
17
18
|
*/
|
|
18
19
|
export const NetCDFLoaderWithParser = {
|
|
20
|
+
createDataSourceSync: createNetCDFSource,
|
|
19
21
|
...NetCDFLoaderMetadataWithoutPreload,
|
|
20
22
|
parse: async (arrayBuffer, options) => parseNetCDF(arrayBuffer, options)
|
|
21
23
|
};
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"netcdf-loader-with-parser.js","sourceRoot":"","sources":["../../src/netcdf/netcdf-loader-with-parser.ts"],"names":[],"mappings":"AAAA,aAAa;AACb,+BAA+B;AAC/B,oCAAoC;
|
|
1
|
+
{"version":3,"file":"netcdf-loader-with-parser.js","sourceRoot":"","sources":["../../src/netcdf/netcdf-loader-with-parser.ts"],"names":[],"mappings":"AAAA,aAAa;AACb,+BAA+B;AAC/B,oCAAoC;AAEpC,OAAO,EAAC,kBAAkB,EAAC,kCAA+B;AAG1D,OAAO,EAAC,YAAY,EAAC,oCAAiC;AACtD,OAAO,EAAC,YAAY,IAAI,0BAA0B,EAAC,2BAAwB;AAC3E,OAAO,EAAC,YAAY,IAAI,oBAAoB,EAAC,2BAAwB;AAErE,MAAM,EAAC,OAAO,EAAE,0BAA0B,EAAE,GAAG,wCAAwC,EAAC,GACtF,0BAA0B,CAAC;AAC7B,MAAM,EAAC,OAAO,EAAE,oBAAoB,EAAE,GAAG,kCAAkC,EAAC,GAAG,oBAAoB,CAAC;AAcpG;;GAEG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAG;IAC1C,GAAG,wCAAwC;CACkB,CAAC;AAEhE;;GAEG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG;IACpC,oBAAoB,EAAE,kBAAkB;IACxC,GAAG,kCAAkC;IACrC,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,EAAE,CAAC,WAAW,CAAC,WAAW,EAAE,OAAO,CAAC;CACD,CAAC;AAE1E,SAAS,WAAW,CAAC,WAAwB,EAAE,OAA6B;IAC1E,MAAM,MAAM,GAAG,IAAI,YAAY,CAAC,WAAW,CAAC,CAAC;IAC7C,MAAM,SAAS,GAAsC,EAAE,CAAC;IACxD,IAAI,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC;QAC9B,KAAK,MAAM,QAAQ,IAAI,MAAM,CAAC,SAAS,EAAE,CAAC;YACxC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC;QAC9D,CAAC;IACH,CAAC;IACD,OAAO;QACL,UAAU,EAAE,MAAM,CAAC,MAAM;QACzB,IAAI,EAAE,SAAS;KAChB,CAAC;AACJ,CAAC"}
|
|
@@ -27,15 +27,14 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
|
|
|
27
27
|
));
|
|
28
28
|
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
|
29
29
|
|
|
30
|
-
//
|
|
30
|
+
// dist/netcdf/netcdf-loader.js
|
|
31
31
|
var netcdf_loader_exports = {};
|
|
32
32
|
__export(netcdf_loader_exports, {
|
|
33
|
-
NetCDFLoader: () => NetCDFLoader
|
|
34
|
-
NetCDFWorkerLoader: () => NetCDFWorkerLoader
|
|
33
|
+
NetCDFLoader: () => NetCDFLoader
|
|
35
34
|
});
|
|
36
35
|
module.exports = __toCommonJS(netcdf_loader_exports);
|
|
37
36
|
|
|
38
|
-
//
|
|
37
|
+
// dist/netcdf/netcdf-format.js
|
|
39
38
|
var NetCDFFormat = {
|
|
40
39
|
name: "NetCDF",
|
|
41
40
|
id: "netcdf",
|
|
@@ -47,13 +46,18 @@ var NetCDFFormat = {
|
|
|
47
46
|
binary: true
|
|
48
47
|
};
|
|
49
48
|
|
|
50
|
-
//
|
|
51
|
-
var VERSION =
|
|
49
|
+
// dist/netcdf/netcdf-loader.js
|
|
50
|
+
var VERSION = true ? "5.0.0-beta.10" : "latest";
|
|
52
51
|
async function preload() {
|
|
53
52
|
const { NetCDFLoaderWithParser } = await import("@loaders.gl/scientific/netcdf/netcdf-loader-with-parser");
|
|
54
53
|
return NetCDFLoaderWithParser;
|
|
55
54
|
}
|
|
56
55
|
var NetCDFLoader = {
|
|
56
|
+
/** Matches input for source selection. */
|
|
57
|
+
testURL: (url) => /\.(?:cdf|nc)(?:$|[?#])/i.test(url),
|
|
58
|
+
fromUrl: true,
|
|
59
|
+
fromBlob: true,
|
|
60
|
+
type: "netcdf",
|
|
57
61
|
...NetCDFFormat,
|
|
58
62
|
dataType: null,
|
|
59
63
|
batchType: null,
|
|
@@ -76,9 +80,8 @@ var NetCDFLoader = {
|
|
|
76
80
|
},
|
|
77
81
|
preload
|
|
78
82
|
};
|
|
79
|
-
var NetCDFWorkerLoader = NetCDFLoader;
|
|
80
83
|
// Annotate the CommonJS export names for ESM import in node:
|
|
81
84
|
0 && (module.exports = {
|
|
82
|
-
NetCDFLoader
|
|
83
|
-
NetCDFWorkerLoader
|
|
85
|
+
NetCDFLoader
|
|
84
86
|
});
|
|
87
|
+
//# sourceMappingURL=netcdf-loader.cjs.map
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
{
|
|
2
|
+
"version": 3,
|
|
3
|
+
"sources": ["../../src/netcdf/netcdf-loader.ts", "../../src/netcdf/netcdf-format.ts"],
|
|
4
|
+
"sourcesContent": ["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport type {Loader, LoaderOptions} from '@loaders.gl/core/loader-utils';\nimport type {NetCDFHeader} from './netcdfjs/netcdf-types';\n\nimport {NetCDFFormat} from './netcdf-format';\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n\nexport type NetCDF = {\n loaderData: NetCDFHeader;\n data: {[variableName: string]: any[][]};\n};\n\nexport type NetCDFLoaderOptions = LoaderOptions & {\n netcdf?: {\n loadData?: boolean;\n loadVariables?: boolean;\n };\n};\n\n/** Preloads the parser-bearing NetCDF loader implementation. */\nasync function preload() {\n const {NetCDFLoaderWithParser} = await import(\n '@loaders.gl/scientific/netcdf/netcdf-loader-with-parser'\n );\n return NetCDFLoaderWithParser;\n}\n\n/**\n * Metadata-only loader for NETCDF.\n */\nexport const NetCDFLoader = {\n /** Matches input for source selection. */\n testURL: (url: string): boolean => /\\.(?:cdf|nc)(?:$|[?#])/i.test(url),\n fromUrl: true,\n fromBlob: true,\n type: 'netcdf',\n ...NetCDFFormat,\n dataType: null as unknown as NetCDF,\n batchType: null as never,\n\n name: 'NetCDF',\n id: 'mvt',\n module: 'scientific',\n version: VERSION,\n extensions: ['cdf', 'nc'],\n mimeTypes: [\n 'application/netcdf',\n 'application/x-netcdf'\n // 'application/octet-stream'\n ],\n category: 'image',\n binary: true,\n options: {\n netcdf: {\n loadVariables: false\n }\n },\n preload\n} as const satisfies Loader<NetCDF, never, NetCDFLoaderOptions>;\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport type {Format} from '@loaders.gl/core/loader-utils';\n\nexport const NetCDFFormat = {\n name: 'NetCDF',\n id: 'netcdf',\n module: 'netcdf',\n encoding: 'binary',\n format: 'netcdf',\n extensions: ['cdf', 'nc'],\n mimeTypes: ['application/x-netcdf'],\n binary: true\n} as const satisfies Format;\n"],
|
|
5
|
+
"mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;;ACMO,IAAM,eAAe;EAC1B,MAAM;EACN,IAAI;EACJ,QAAQ;EACR,UAAU;EACV,QAAQ;EACR,YAAY,CAAC,OAAO,IAAI;EACxB,WAAW,CAAC,sBAAsB;EAClC,QAAQ;;;;ADJV,IAAM,UAAU,OAAoC,kBAAe;AAenE,eAAe,UAAO;AACpB,QAAM,EAAC,uBAAsB,IAAI,MAAM,OACrC,yDAAyD;AAE3D,SAAO;AACT;AAKO,IAAM,eAAe;;EAE1B,SAAS,CAAC,QAAyB,0BAA0B,KAAK,GAAG;EACrE,SAAS;EACT,UAAU;EACV,MAAM;EACN,GAAG;EACH,UAAU;EACV,WAAW;EAEX,MAAM;EACN,IAAI;EACJ,QAAQ;EACR,SAAS;EACT,YAAY,CAAC,OAAO,IAAI;EACxB,WAAW;IACT;IACA;;;EAGF,UAAU;EACV,QAAQ;EACR,SAAS;IACP,QAAQ;MACN,eAAe;;;EAGnB;;",
|
|
6
|
+
"names": []
|
|
7
|
+
}
|
|
@@ -32,6 +32,11 @@ declare function preload(): Promise<{
|
|
|
32
32
|
};
|
|
33
33
|
readonly encoding: "binary";
|
|
34
34
|
readonly format: "netcdf";
|
|
35
|
+
readonly testURL: (url: string) => boolean;
|
|
36
|
+
readonly fromUrl: true;
|
|
37
|
+
readonly fromBlob: true;
|
|
38
|
+
readonly type: "netcdf";
|
|
39
|
+
readonly createDataSourceSync: typeof import("./netcdf-source-loader").createNetCDFSource;
|
|
35
40
|
}>;
|
|
36
41
|
/**
|
|
37
42
|
* Metadata-only loader for NETCDF.
|
|
@@ -55,27 +60,11 @@ export declare const NetCDFLoader: {
|
|
|
55
60
|
readonly preload: typeof preload;
|
|
56
61
|
readonly encoding: "binary";
|
|
57
62
|
readonly format: "netcdf";
|
|
58
|
-
|
|
59
|
-
|
|
60
|
-
|
|
61
|
-
readonly
|
|
62
|
-
readonly
|
|
63
|
-
readonly name: "NetCDF";
|
|
64
|
-
readonly id: "mvt";
|
|
65
|
-
readonly module: "scientific";
|
|
66
|
-
readonly version: any;
|
|
67
|
-
readonly extensions: ["cdf", "nc"];
|
|
68
|
-
readonly mimeTypes: ["application/netcdf", "application/x-netcdf"];
|
|
69
|
-
readonly category: "image";
|
|
70
|
-
readonly binary: true;
|
|
71
|
-
readonly options: {
|
|
72
|
-
readonly netcdf: {
|
|
73
|
-
readonly loadVariables: false;
|
|
74
|
-
};
|
|
75
|
-
};
|
|
76
|
-
readonly preload: typeof preload;
|
|
77
|
-
readonly encoding: "binary";
|
|
78
|
-
readonly format: "netcdf";
|
|
63
|
+
/** Matches input for source selection. */
|
|
64
|
+
readonly testURL: (url: string) => boolean;
|
|
65
|
+
readonly fromUrl: true;
|
|
66
|
+
readonly fromBlob: true;
|
|
67
|
+
readonly type: "netcdf";
|
|
79
68
|
};
|
|
80
69
|
export {};
|
|
81
70
|
//# sourceMappingURL=netcdf-loader.d.ts.map
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"netcdf-loader.d.ts","sourceRoot":"","sources":["../../src/netcdf/netcdf-loader.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAS,aAAa,EAAC,MAAM,+BAA+B,CAAC;AACzE,OAAO,KAAK,EAAC,YAAY,EAAC,mCAAgC;AAO1D,MAAM,MAAM,MAAM,GAAG;IACnB,UAAU,EAAE,YAAY,CAAC;IACzB,IAAI,EAAE;QAAC,CAAC,YAAY,EAAE,MAAM,GAAG,GAAG,EAAE,EAAE,CAAA;KAAC,CAAC;CACzC,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG,aAAa,GAAG;IAChD,MAAM,CAAC,EAAE;QACP,QAAQ,CAAC,EAAE,OAAO,CAAC;QACnB,aAAa,CAAC,EAAE,OAAO,CAAC;KACzB,CAAC;CACH,CAAC;AAEF,gEAAgE;AAChE,iBAAe,OAAO;;
|
|
1
|
+
{"version":3,"file":"netcdf-loader.d.ts","sourceRoot":"","sources":["../../src/netcdf/netcdf-loader.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAS,aAAa,EAAC,MAAM,+BAA+B,CAAC;AACzE,OAAO,KAAK,EAAC,YAAY,EAAC,mCAAgC;AAO1D,MAAM,MAAM,MAAM,GAAG;IACnB,UAAU,EAAE,YAAY,CAAC;IACzB,IAAI,EAAE;QAAC,CAAC,YAAY,EAAE,MAAM,GAAG,GAAG,EAAE,EAAE,CAAA;KAAC,CAAC;CACzC,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG,aAAa,GAAG;IAChD,MAAM,CAAC,EAAE;QACP,QAAQ,CAAC,EAAE,OAAO,CAAC;QACnB,aAAa,CAAC,EAAE,OAAO,CAAC;KACzB,CAAC;CACH,CAAC;AAEF,gEAAgE;AAChE,iBAAe,OAAO;;uBAiBS,MAAM;wBAChB,KAAK;;;;;;;;;;;;;;;;4BANT,MAAM,KAAG,OAAO;;;;;GAPhC;AAED;;GAEG;AACH,eAAO,MAAM,YAAY;uBAOM,MAAM;wBAChB,KAAK;;;;;;;;;;;;;;;;;IAPxB,0CAA0C;4BAC3B,MAAM,KAAG,OAAO;;;;CA0B8B,CAAC"}
|
|
@@ -4,7 +4,7 @@
|
|
|
4
4
|
import { NetCDFFormat } from "./netcdf-format.js";
|
|
5
5
|
// __VERSION__ is injected by babel-plugin-version-inline
|
|
6
6
|
// @ts-ignore TS2304: Cannot find name '__VERSION__'.
|
|
7
|
-
const VERSION = typeof "5.0.0-beta.
|
|
7
|
+
const VERSION = typeof "5.0.0-beta.10" !== 'undefined' ? "5.0.0-beta.10" : 'latest';
|
|
8
8
|
/** Preloads the parser-bearing NetCDF loader implementation. */
|
|
9
9
|
async function preload() {
|
|
10
10
|
const { NetCDFLoaderWithParser } = await import('@loaders.gl/scientific/netcdf/netcdf-loader-with-parser');
|
|
@@ -14,6 +14,11 @@ async function preload() {
|
|
|
14
14
|
* Metadata-only loader for NETCDF.
|
|
15
15
|
*/
|
|
16
16
|
export const NetCDFLoader = {
|
|
17
|
+
/** Matches input for source selection. */
|
|
18
|
+
testURL: (url) => /\.(?:cdf|nc)(?:$|[?#])/i.test(url),
|
|
19
|
+
fromUrl: true,
|
|
20
|
+
fromBlob: true,
|
|
21
|
+
type: 'netcdf',
|
|
17
22
|
...NetCDFFormat,
|
|
18
23
|
dataType: null,
|
|
19
24
|
batchType: null,
|
|
@@ -36,6 +41,4 @@ export const NetCDFLoader = {
|
|
|
36
41
|
},
|
|
37
42
|
preload
|
|
38
43
|
};
|
|
39
|
-
/** @deprecated Use NetCDFLoader. */
|
|
40
|
-
export const NetCDFWorkerLoader = NetCDFLoader;
|
|
41
44
|
//# sourceMappingURL=netcdf-loader.js.map
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"netcdf-loader.js","sourceRoot":"","sources":["../../src/netcdf/netcdf-loader.ts"],"names":[],"mappings":"AAAA,aAAa;AACb,+BAA+B;AAC/B,oCAAoC;AAKpC,OAAO,EAAC,YAAY,EAAC,2BAAwB;AAC7C,yDAAyD;AACzD,qDAAqD;AACrD,MAAM,OAAO,GAAG,
|
|
1
|
+
{"version":3,"file":"netcdf-loader.js","sourceRoot":"","sources":["../../src/netcdf/netcdf-loader.ts"],"names":[],"mappings":"AAAA,aAAa;AACb,+BAA+B;AAC/B,oCAAoC;AAKpC,OAAO,EAAC,YAAY,EAAC,2BAAwB;AAC7C,yDAAyD;AACzD,qDAAqD;AACrD,MAAM,OAAO,GAAG,sBAAkB,KAAK,WAAW,CAAC,CAAC,iBAAa,CAAC,CAAC,QAAQ,CAAC;AAc5E,gEAAgE;AAChE,KAAK,UAAU,OAAO;IACpB,MAAM,EAAC,sBAAsB,EAAC,GAAG,MAAM,MAAM,CAC3C,yDAAyD,CAC1D,CAAC;IACF,OAAO,sBAAsB,CAAC;AAChC,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,0CAA0C;IAC1C,OAAO,EAAE,CAAC,GAAW,EAAW,EAAE,CAAC,yBAAyB,CAAC,IAAI,CAAC,GAAG,CAAC;IACtE,OAAO,EAAE,IAAI;IACb,QAAQ,EAAE,IAAI;IACd,IAAI,EAAE,QAAQ;IACd,GAAG,YAAY;IACf,QAAQ,EAAE,IAAyB;IACnC,SAAS,EAAE,IAAa;IAExB,IAAI,EAAE,QAAQ;IACd,EAAE,EAAE,KAAK;IACT,MAAM,EAAE,YAAY;IACpB,OAAO,EAAE,OAAO;IAChB,UAAU,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC;IACzB,SAAS,EAAE;QACT,oBAAoB;QACpB,sBAAsB;QACtB,6BAA6B;KAC9B;IACD,QAAQ,EAAE,OAAO;IACjB,MAAM,EAAE,IAAI;IACZ,OAAO,EAAE;QACP,MAAM,EAAE;YACN,aAAa,EAAE,KAAK;SACrB;KACF;IACD,OAAO;CACsD,CAAC"}
|