@loaders.gl/netcdf 4.0.0-alpha.9 → 4.0.0-beta.2

package/dist/es5/netcdf-loader.js

@@ -4,7 +4,7 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports._typecheckNetCDFWorkerLoader = exports._typecheckNetCDFLoader = exports.NetCDFWorkerLoader = exports.NetCDFLoader = void 0;
+exports.NetCDFWorkerLoader = exports.NetCDFLoader = void 0;
 var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
 var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
@@ -14,7 +14,7 @@ function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o =
 function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-var VERSION = typeof "4.0.0-alpha.9" !== 'undefined' ? "4.0.0-alpha.9" : 'latest';
+var VERSION = typeof "4.0.0-beta.2" !== 'undefined' ? "4.0.0-beta.2" : 'latest';
 var NetCDFWorkerLoader = {
   name: 'NetCDF',
   id: 'mvt',
@@ -74,8 +74,4 @@ function parseNetCDF(arrayBuffer, options) {
     data: variables
   };
 }
-var _typecheckNetCDFWorkerLoader = NetCDFWorkerLoader;
-exports._typecheckNetCDFWorkerLoader = _typecheckNetCDFWorkerLoader;
-var _typecheckNetCDFLoader = NetCDFLoader;
-exports._typecheckNetCDFLoader = _typecheckNetCDFLoader;
 //# sourceMappingURL=netcdf-loader.js.map

package/dist/es5/netcdf-loader.js.map

@@ -1 +1 @@
-{"version":3,"file":"netcdf-loader.js","names":["_netcdfReader","require","_createForOfIteratorHelper","o","allowArrayLike","it","Symbol","iterator","Array","isArray","_unsupportedIterableToArray","length","i","F","s","n","done","value","e","_e","f","TypeError","normalCompletion","didErr","err","call","step","next","_e2","return","minLen","_arrayLikeToArray","Object","prototype","toString","slice","constructor","name","from","test","arr","len","arr2","ownKeys","object","enumerableOnly","keys","getOwnPropertySymbols","symbols","filter","sym","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","target","arguments","source","forEach","key","_defineProperty2","default","getOwnPropertyDescriptors","defineProperties","defineProperty","VERSION","NetCDFWorkerLoader","id","module","version","extensions","mimeTypes","category","options","netcdf","loadVariables","exports","NetCDFLoader","parse","_parse","_asyncToGenerator2","_regenerator","mark","_callee","arrayBuffer","wrap","_callee$","_context","prev","abrupt","parseNetCDF","stop","_x","_x2","binary","_options$netcdf","reader","NetCDFReader","variables","loadData","_iterator","_step","variable","getDataVariable","loaderData","header","data","_typecheckNetCDFWorkerLoader","_typecheckNetCDFLoader"],"sources":["../../src/netcdf-loader.ts"],"sourcesContent":["import type {Loader, LoaderWithParser, LoaderOptions} from '@loaders.gl/loader-utils';\nimport type {NetCDFHeader} from './netcdfjs/netcdf-types';\nimport {NetCDFReader} from './netcdfjs/netcdf-reader';\n\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  };\n};\n\n/**\n * Worker loader for NETCDF\n */\nexport const NetCDFWorkerLoader = {\n  name: 'NetCDF',\n  id: 'mvt',\n  module: 'mvt',\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  options: {\n    netcdf: {\n      loadVariables: false\n    }\n  }\n};\n\n/**\n * Loader for the NetCDF format\n */\nexport const NetCDFLoader = {\n  ...NetCDFWorkerLoader,\n  parse: async (arrayBuffer, options) => parseNetCDF(arrayBuffer, options),\n  binary: true\n};\n\nfunction parseNetCDF(arrayBuffer: ArrayBuffer, options?: NetCDFLoaderOptions): NetCDF {\n  const reader = new NetCDFReader(arrayBuffer);\n  const variables: {[variableName: string]: any[][]} = {};\n  if (options?.netcdf?.loadData) {\n    for (const variable of reader.variables) {\n      variables[variable.name] = reader.getDataVariable(variable);\n    }\n  }\n  return {\n    loaderData: reader.header,\n    data: variables\n  };\n}\n\n// Type tests\nexport const _typecheckNetCDFWorkerLoader: Loader = NetCDFWorkerLoader;\nexport const _typecheckNetCDFLoader: LoaderWithParser = NetCDFLoader;\n"],"mappings":"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"}
+{"version":3,"file":"netcdf-loader.js","names":["_netcdfReader","require","_createForOfIteratorHelper","o","allowArrayLike","it","Symbol","iterator","Array","isArray","_unsupportedIterableToArray","length","i","F","s","n","done","value","e","_e","f","TypeError","normalCompletion","didErr","err","call","step","next","_e2","return","minLen","_arrayLikeToArray","Object","prototype","toString","slice","constructor","name","from","test","arr","len","arr2","ownKeys","object","enumerableOnly","keys","getOwnPropertySymbols","symbols","filter","sym","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","target","arguments","source","forEach","key","_defineProperty2","default","getOwnPropertyDescriptors","defineProperties","defineProperty","VERSION","NetCDFWorkerLoader","id","module","version","extensions","mimeTypes","category","options","netcdf","loadVariables","exports","NetCDFLoader","parse","_parse","_asyncToGenerator2","_regenerator","mark","_callee","arrayBuffer","wrap","_callee$","_context","prev","abrupt","parseNetCDF","stop","_x","_x2","binary","_options$netcdf","reader","NetCDFReader","variables","loadData","_iterator","_step","variable","getDataVariable","loaderData","header","data"],"sources":["../../src/netcdf-loader.ts"],"sourcesContent":["import type {Loader, LoaderWithParser, LoaderOptions} from '@loaders.gl/loader-utils';\nimport type {NetCDFHeader} from './netcdfjs/netcdf-types';\nimport {NetCDFReader} from './netcdfjs/netcdf-reader';\n\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/**\n * Worker loader for NETCDF\n */\nexport const NetCDFWorkerLoader: Loader<NetCDF, never, NetCDFLoaderOptions> = {\n  name: 'NetCDF',\n  id: 'mvt',\n  module: 'mvt',\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  options: {\n    netcdf: {\n      loadVariables: false\n    }\n  }\n};\n\n/**\n * Loader for the NetCDF format\n */\nexport const NetCDFLoader: LoaderWithParser<NetCDF, never, NetCDFLoaderOptions> = {\n  ...NetCDFWorkerLoader,\n  parse: async (arrayBuffer, options) => parseNetCDF(arrayBuffer, options),\n  binary: true\n};\n\nfunction parseNetCDF(arrayBuffer: ArrayBuffer, options?: NetCDFLoaderOptions): NetCDF {\n  const reader = new NetCDFReader(arrayBuffer);\n  const variables: {[variableName: string]: any[][]} = {};\n  if (options?.netcdf?.loadData) {\n    for (const variable of reader.variables) {\n      variables[variable.name] = reader.getDataVariable(variable);\n    }\n  }\n  return {\n    loaderData: reader.header,\n    data: variables\n  };\n}\n"],"mappings":"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"}

package/dist/esm/netcdf-loader.js

@@ -1,5 +1,5 @@
 import { NetCDFReader } from './netcdfjs/netcdf-reader';
-const VERSION = typeof "4.0.0-alpha.9" !== 'undefined' ? "4.0.0-alpha.9" : 'latest';
+const VERSION = typeof "4.0.0-beta.2" !== 'undefined' ? "4.0.0-beta.2" : 'latest';
 export const NetCDFWorkerLoader = {
   name: 'NetCDF',
   id: 'mvt',
@@ -33,6 +33,4 @@ function parseNetCDF(arrayBuffer, options) {
     data: variables
   };
 }
-export const _typecheckNetCDFWorkerLoader = NetCDFWorkerLoader;
-export const _typecheckNetCDFLoader = NetCDFLoader;
 //# sourceMappingURL=netcdf-loader.js.map

package/dist/esm/netcdf-loader.js.map

@@ -1 +1 @@
-{"version":3,"file":"netcdf-loader.js","names":["NetCDFReader","VERSION","NetCDFWorkerLoader","name","id","module","version","extensions","mimeTypes","category","options","netcdf","loadVariables","NetCDFLoader","parse","arrayBuffer","parseNetCDF","binary","_options$netcdf","reader","variables","loadData","variable","getDataVariable","loaderData","header","data","_typecheckNetCDFWorkerLoader","_typecheckNetCDFLoader"],"sources":["../../src/netcdf-loader.ts"],"sourcesContent":["import type {Loader, LoaderWithParser, LoaderOptions} from '@loaders.gl/loader-utils';\nimport type {NetCDFHeader} from './netcdfjs/netcdf-types';\nimport {NetCDFReader} from './netcdfjs/netcdf-reader';\n\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  };\n};\n\n/**\n * Worker loader for NETCDF\n */\nexport const NetCDFWorkerLoader = {\n  name: 'NetCDF',\n  id: 'mvt',\n  module: 'mvt',\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  options: {\n    netcdf: {\n      loadVariables: false\n    }\n  }\n};\n\n/**\n * Loader for the NetCDF format\n */\nexport const NetCDFLoader = {\n  ...NetCDFWorkerLoader,\n  parse: async (arrayBuffer, options) => parseNetCDF(arrayBuffer, options),\n  binary: true\n};\n\nfunction parseNetCDF(arrayBuffer: ArrayBuffer, options?: NetCDFLoaderOptions): NetCDF {\n  const reader = new NetCDFReader(arrayBuffer);\n  const variables: {[variableName: string]: any[][]} = {};\n  if (options?.netcdf?.loadData) {\n    for (const variable of reader.variables) {\n      variables[variable.name] = reader.getDataVariable(variable);\n    }\n  }\n  return {\n    loaderData: reader.header,\n    data: variables\n  };\n}\n\n// Type tests\nexport const _typecheckNetCDFWorkerLoader: Loader = NetCDFWorkerLoader;\nexport const _typecheckNetCDFLoader: LoaderWithParser = NetCDFLoader;\n"],"mappings":"AAEA,SAAQA,YAAY,QAAO,0BAA0B;AAIrD,MAAMC,OAAO,GAAG,sBAAkB,KAAK,WAAW,qBAAiB,QAAQ;AAgB3E,OAAO,MAAMC,kBAAkB,GAAG;EAChCC,IAAI,EAAE,QAAQ;EACdC,EAAE,EAAE,KAAK;EACTC,MAAM,EAAE,KAAK;EACbC,OAAO,EAAEL,OAAO;EAChBM,UAAU,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC;EACzBC,SAAS,EAAE,CACT,oBAAoB,EACpB,sBAAsB,CAEvB;EACDC,QAAQ,EAAE,OAAO;EACjBC,OAAO,EAAE;IACPC,MAAM,EAAE;MACNC,aAAa,EAAE;IACjB;EACF;AACF,CAAC;AAKD,OAAO,MAAMC,YAAY,GAAG;EAC1B,GAAGX,kBAAkB;EACrBY,KAAK,EAAE,MAAAA,CAAOC,WAAW,EAAEL,OAAO,KAAKM,WAAW,CAACD,WAAW,EAAEL,OAAO,CAAC;EACxEO,MAAM,EAAE;AACV,CAAC;AAED,SAASD,WAAWA,CAACD,WAAwB,EAAEL,OAA6B,EAAU;EAAA,IAAAQ,eAAA;EACpF,MAAMC,MAAM,GAAG,IAAInB,YAAY,CAACe,WAAW,CAAC;EAC5C,MAAMK,SAA4C,GAAG,CAAC,CAAC;EACvD,IAAIV,OAAO,aAAPA,OAAO,gBAAAQ,eAAA,GAAPR,OAAO,CAAEC,MAAM,cAAAO,eAAA,eAAfA,eAAA,CAAiBG,QAAQ,EAAE;IAC7B,KAAK,MAAMC,QAAQ,IAAIH,MAAM,CAACC,SAAS,EAAE;MACvCA,SAAS,CAACE,QAAQ,CAACnB,IAAI,CAAC,GAAGgB,MAAM,CAACI,eAAe,CAACD,QAAQ,CAAC;IAC7D;EACF;EACA,OAAO;IACLE,UAAU,EAAEL,MAAM,CAACM,MAAM;IACzBC,IAAI,EAAEN;EACR,CAAC;AACH;AAGA,OAAO,MAAMO,4BAAoC,GAAGzB,kBAAkB;AACtE,OAAO,MAAM0B,sBAAwC,GAAGf,YAAY"}
+{"version":3,"file":"netcdf-loader.js","names":["NetCDFReader","VERSION","NetCDFWorkerLoader","name","id","module","version","extensions","mimeTypes","category","options","netcdf","loadVariables","NetCDFLoader","parse","arrayBuffer","parseNetCDF","binary","_options$netcdf","reader","variables","loadData","variable","getDataVariable","loaderData","header","data"],"sources":["../../src/netcdf-loader.ts"],"sourcesContent":["import type {Loader, LoaderWithParser, LoaderOptions} from '@loaders.gl/loader-utils';\nimport type {NetCDFHeader} from './netcdfjs/netcdf-types';\nimport {NetCDFReader} from './netcdfjs/netcdf-reader';\n\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/**\n * Worker loader for NETCDF\n */\nexport const NetCDFWorkerLoader: Loader<NetCDF, never, NetCDFLoaderOptions> = {\n  name: 'NetCDF',\n  id: 'mvt',\n  module: 'mvt',\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  options: {\n    netcdf: {\n      loadVariables: false\n    }\n  }\n};\n\n/**\n * Loader for the NetCDF format\n */\nexport const NetCDFLoader: LoaderWithParser<NetCDF, never, NetCDFLoaderOptions> = {\n  ...NetCDFWorkerLoader,\n  parse: async (arrayBuffer, options) => parseNetCDF(arrayBuffer, options),\n  binary: true\n};\n\nfunction parseNetCDF(arrayBuffer: ArrayBuffer, options?: NetCDFLoaderOptions): NetCDF {\n  const reader = new NetCDFReader(arrayBuffer);\n  const variables: {[variableName: string]: any[][]} = {};\n  if (options?.netcdf?.loadData) {\n    for (const variable of reader.variables) {\n      variables[variable.name] = reader.getDataVariable(variable);\n    }\n  }\n  return {\n    loaderData: reader.header,\n    data: variables\n  };\n}\n"],"mappings":"AAEA,SAAQA,YAAY,QAAO,0BAA0B;AAIrD,MAAMC,OAAO,GAAG,qBAAkB,KAAK,WAAW,oBAAiB,QAAQ;AAiB3E,OAAO,MAAMC,kBAA8D,GAAG;EAC5EC,IAAI,EAAE,QAAQ;EACdC,EAAE,EAAE,KAAK;EACTC,MAAM,EAAE,KAAK;EACbC,OAAO,EAAEL,OAAO;EAChBM,UAAU,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC;EACzBC,SAAS,EAAE,CACT,oBAAoB,EACpB,sBAAsB,CAEvB;EACDC,QAAQ,EAAE,OAAO;EACjBC,OAAO,EAAE;IACPC,MAAM,EAAE;MACNC,aAAa,EAAE;IACjB;EACF;AACF,CAAC;AAKD,OAAO,MAAMC,YAAkE,GAAG;EAChF,GAAGX,kBAAkB;EACrBY,KAAK,EAAE,MAAAA,CAAOC,WAAW,EAAEL,OAAO,KAAKM,WAAW,CAACD,WAAW,EAAEL,OAAO,CAAC;EACxEO,MAAM,EAAE;AACV,CAAC;AAED,SAASD,WAAWA,CAACD,WAAwB,EAAEL,OAA6B,EAAU;EAAA,IAAAQ,eAAA;EACpF,MAAMC,MAAM,GAAG,IAAInB,YAAY,CAACe,WAAW,CAAC;EAC5C,MAAMK,SAA4C,GAAG,CAAC,CAAC;EACvD,IAAIV,OAAO,aAAPA,OAAO,gBAAAQ,eAAA,GAAPR,OAAO,CAAEC,MAAM,cAAAO,eAAA,eAAfA,eAAA,CAAiBG,QAAQ,EAAE;IAC7B,KAAK,MAAMC,QAAQ,IAAIH,MAAM,CAACC,SAAS,EAAE;MACvCA,SAAS,CAACE,QAAQ,CAACnB,IAAI,CAAC,GAAGgB,MAAM,CAACI,eAAe,CAACD,QAAQ,CAAC;IAC7D;EACF;EACA,OAAO;IACLE,UAAU,EAAEL,MAAM,CAACM,MAAM;IACzBC,IAAI,EAAEN;EACR,CAAC;AACH"}

package/dist/netcdf-loader.d.ts

@@ -9,44 +9,15 @@ export type NetCDF = {
 export type NetCDFLoaderOptions = LoaderOptions & {
     netcdf?: {
         loadData?: boolean;
+        loadVariables?: boolean;
     };
 };
 /**
  * Worker loader for NETCDF
  */
-export declare const NetCDFWorkerLoader: {
-    name: string;
-    id: string;
-    module: string;
-    version: any;
-    extensions: string[];
-    mimeTypes: string[];
-    category: string;
-    options: {
-        netcdf: {
-            loadVariables: boolean;
-        };
-    };
-};
+export declare const NetCDFWorkerLoader: Loader<NetCDF, never, NetCDFLoaderOptions>;
 /**
  * Loader for the NetCDF format
  */
-export declare const NetCDFLoader: {
-    parse: (arrayBuffer: any, options: any) => Promise<NetCDF>;
-    binary: boolean;
-    name: string;
-    id: string;
-    module: string;
-    version: any;
-    extensions: string[];
-    mimeTypes: string[];
-    category: string;
-    options: {
-        netcdf: {
-            loadVariables: boolean;
-        };
-    };
-};
-export declare const _typecheckNetCDFWorkerLoader: Loader;
-export declare const _typecheckNetCDFLoader: LoaderWithParser;
+export declare const NetCDFLoader: LoaderWithParser<NetCDF, never, NetCDFLoaderOptions>;
 //# sourceMappingURL=netcdf-loader.d.ts.map

package/dist/netcdf-loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"netcdf-loader.d.ts","sourceRoot":"","sources":["../src/netcdf-loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,MAAM,EAAE,gBAAgB,EAAE,aAAa,EAAC,MAAM,0BAA0B,CAAC;AACtF,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,yBAAyB,CAAC;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;KACpB,CAAC;CACH,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;CAiB9B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;CAIxB,CAAC;AAiBF,eAAO,MAAM,4BAA4B,EAAE,MAA2B,CAAC;AACvE,eAAO,MAAM,sBAAsB,EAAE,gBAA+B,CAAC"}
+{"version":3,"file":"netcdf-loader.d.ts","sourceRoot":"","sources":["../src/netcdf-loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,MAAM,EAAE,gBAAgB,EAAE,aAAa,EAAC,MAAM,0BAA0B,CAAC;AACtF,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,yBAAyB,CAAC;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;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,EAAE,mBAAmB,CAiBzE,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,YAAY,EAAE,gBAAgB,CAAC,MAAM,EAAE,KAAK,EAAE,mBAAmB,CAI7E,CAAC"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@loaders.gl/netcdf",
   "description": "Loader for NetCDF",
-  "version": "4.0.0-alpha.9",
+  "version": "4.0.0-beta.2",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
@@ -30,7 +30,7 @@
     "build-bundle": "esbuild src/bundle.ts --bundle --outfile=dist/dist.min.js"
   },
   "dependencies": {
-    "@loaders.gl/loader-utils": "4.0.0-alpha.9"
+    "@loaders.gl/loader-utils": "4.0.0-beta.2"
   },
-  "gitHead": "03ff81ab468f20f3bddeec787aa88d477a7e1c72"
+  "gitHead": "79c2033f755e88e11bc30a04428e3666b177b8fc"
 }

package/src/netcdf-loader.ts

@@ -14,13 +14,14 @@ export type NetCDF = {
 export type NetCDFLoaderOptions = LoaderOptions & {
   netcdf?: {
     loadData?: boolean;
+    loadVariables?: boolean;
   };
 };
 
 /**
  * Worker loader for NETCDF
  */
-export const NetCDFWorkerLoader = {
+export const NetCDFWorkerLoader: Loader<NetCDF, never, NetCDFLoaderOptions> = {
   name: 'NetCDF',
   id: 'mvt',
   module: 'mvt',
@@ -42,7 +43,7 @@ export const NetCDFWorkerLoader = {
 /**
  * Loader for the NetCDF format
  */
-export const NetCDFLoader = {
+export const NetCDFLoader: LoaderWithParser<NetCDF, never, NetCDFLoaderOptions> = {
   ...NetCDFWorkerLoader,
   parse: async (arrayBuffer, options) => parseNetCDF(arrayBuffer, options),
   binary: true
@@ -61,7 +62,3 @@ function parseNetCDF(arrayBuffer: ArrayBuffer, options?: NetCDFLoaderOptions): N
     data: variables
   };
 }
-
-// Type tests
-export const _typecheckNetCDFWorkerLoader: Loader = NetCDFWorkerLoader;
-export const _typecheckNetCDFLoader: LoaderWithParser = NetCDFLoader;

package/dist/index.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NetCDFLoader = exports.NetCDFReader = void 0;
-var netcdf_reader_1 = require("./netcdfjs/netcdf-reader");
-Object.defineProperty(exports, "NetCDFReader", { enumerable: true, get: function () { return netcdf_reader_1.NetCDFReader; } });
-var netcdf_loader_1 = require("./netcdf-loader");
-Object.defineProperty(exports, "NetCDFLoader", { enumerable: true, get: function () { return netcdf_loader_1.NetCDFLoader; } });

package/dist/iobuffer/iobuffer.js

@@ -1,427 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IOBuffer = void 0;
-const DEFAULT_BYTE_LENGTH = 1024 * 8;
-class IOBuffer {
-    /**
-     * @param data - The data to construct the IOBuffer with.
-     * If data is a number, it will be the new buffer's length<br>
-     * If data is `undefined`, the buffer will be initialized with a default length of 8Kb<br>
-     * If data is an ArrayBuffer, SharedArrayBuffer, an ArrayBufferView (Typed Array), an IOBuffer instance,
-     * or a Node.js Buffer, a view will be created over the underlying ArrayBuffer.
-     * @param options
-     */
-    constructor(data = DEFAULT_BYTE_LENGTH, options = {}) {
-        this.textDecoder = new TextDecoder();
-        this.textEncoder = new TextEncoder();
-        let dataIsGiven = false;
-        if (typeof data === 'number') {
-            data = new ArrayBuffer(data);
-        }
-        else {
-            dataIsGiven = true;
-            this.lastWrittenByte = data.byteLength;
-        }
-        const offset = options.offset ? options.offset >>> 0 : 0;
-        const byteLength = data.byteLength - offset;
-        let dvOffset = offset;
-        if (ArrayBuffer.isView(data) || data instanceof IOBuffer) {
-            if (data.byteLength !== data.buffer.byteLength) {
-                dvOffset = data.byteOffset + offset;
-            }
-            data = data.buffer;
-        }
-        if (dataIsGiven) {
-            this.lastWrittenByte = byteLength;
-        }
-        else {
-            this.lastWrittenByte = 0;
-        }
-        this.buffer = data;
-        this.length = byteLength;
-        this.byteLength = byteLength;
-        this.byteOffset = dvOffset;
-        this.offset = 0;
-        this.littleEndian = true;
-        this._data = new DataView(this.buffer, dvOffset, byteLength);
-        this._mark = 0;
-        this._marks = [];
-    }
-    /**
-     * Checks if the memory allocated to the buffer is sufficient to store more
-     * bytes after the offset.
-     * @param byteLength - The needed memory in bytes.
-     * @returns `true` if there is sufficient space and `false` otherwise.
-     */
-    available(byteLength = 1) {
-        return this.offset + byteLength <= this.length;
-    }
-    /**
-     * Check if little-endian mode is used for reading and writing multi-byte
-     * values.
-     * @returns `true` if little-endian mode is used, `false` otherwise.
-     */
-    isLittleEndian() {
-        return this.littleEndian;
-    }
-    /**
-     * Set little-endian mode for reading and writing multi-byte values.
-     */
-    setLittleEndian() {
-        this.littleEndian = true;
-        return this;
-    }
-    /**
-     * Check if big-endian mode is used for reading and writing multi-byte values.
-     * @returns `true` if big-endian mode is used, `false` otherwise.
-     */
-    isBigEndian() {
-        return !this.littleEndian;
-    }
-    /**
-     * Switches to big-endian mode for reading and writing multi-byte values.
-     */
-    setBigEndian() {
-        this.littleEndian = false;
-        return this;
-    }
-    /**
-     * Move the pointer n bytes forward.
-     * @param n - Number of bytes to skip.
-     */
-    skip(n = 1) {
-        this.offset += n;
-        return this;
-    }
-    /**
-     * Move the pointer to the given offset.
-     * @param offset
-     */
-    seek(offset) {
-        this.offset = offset;
-        return this;
-    }
-    /**
-     * Store the current pointer offset.
-     * @see {@link IOBuffer#reset}
-     */
-    mark() {
-        this._mark = this.offset;
-        return this;
-    }
-    /**
-     * Move the pointer back to the last pointer offset set by mark.
-     * @see {@link IOBuffer#mark}
-     */
-    reset() {
-        this.offset = this._mark;
-        return this;
-    }
-    /**
-     * Push the current pointer offset to the mark stack.
-     * @see {@link IOBuffer#popMark}
-     */
-    pushMark() {
-        this._marks.push(this.offset);
-        return this;
-    }
-    /**
-     * Pop the last pointer offset from the mark stack, and set the current
-     * pointer offset to the popped value.
-     * @see {@link IOBuffer#pushMark}
-     */
-    popMark() {
-        const offset = this._marks.pop();
-        if (offset === undefined) {
-            throw new Error('Mark stack empty');
-        }
-        this.seek(offset);
-        return this;
-    }
-    /**
-     * Move the pointer offset back to 0.
-     */
-    rewind() {
-        this.offset = 0;
-        return this;
-    }
-    /**
-     * Make sure the buffer has sufficient memory to write a given byteLength at
-     * the current pointer offset.
-     * If the buffer's memory is insufficient, this method will create a new
-     * buffer (a copy) with a length that is twice (byteLength + current offset).
-     * @param byteLength
-     */
-    ensureAvailable(byteLength = 1) {
-        if (!this.available(byteLength)) {
-            const lengthNeeded = this.offset + byteLength;
-            const newLength = lengthNeeded * 2;
-            const newArray = new Uint8Array(newLength);
-            newArray.set(new Uint8Array(this.buffer));
-            this.buffer = newArray.buffer;
-            this.length = this.byteLength = newLength;
-            this._data = new DataView(this.buffer);
-        }
-        return this;
-    }
-    /**
-     * Read a byte and return false if the byte's value is 0, or true otherwise.
-     * Moves pointer forward by one byte.
-     */
-    readBoolean() {
-        return this.readUint8() !== 0;
-    }
-    /**
-     * Read a signed 8-bit integer and move pointer forward by 1 byte.
-     */
-    readInt8() {
-        return this._data.getInt8(this.offset++);
-    }
-    /**
-     * Read an unsigned 8-bit integer and move pointer forward by 1 byte.
-     */
-    readUint8() {
-        return this._data.getUint8(this.offset++);
-    }
-    /**
-     * Alias for {@link IOBuffer#readUint8}.
-     */
-    readByte() {
-        return this.readUint8();
-    }
-    /**
-     * Read `n` bytes and move pointer forward by `n` bytes.
-     */
-    readBytes(n = 1) {
-        const bytes = new Uint8Array(n);
-        for (let i = 0; i < n; i++) {
-            bytes[i] = this.readByte();
-        }
-        return bytes;
-    }
-    /**
-     * Read a 16-bit signed integer and move pointer forward by 2 bytes.
-     */
-    readInt16() {
-        const value = this._data.getInt16(this.offset, this.littleEndian);
-        this.offset += 2;
-        return value;
-    }
-    /**
-     * Read a 16-bit unsigned integer and move pointer forward by 2 bytes.
-     */
-    readUint16() {
-        const value = this._data.getUint16(this.offset, this.littleEndian);
-        this.offset += 2;
-        return value;
-    }
-    /**
-     * Read a 32-bit signed integer and move pointer forward by 4 bytes.
-     */
-    readInt32() {
-        const value = this._data.getInt32(this.offset, this.littleEndian);
-        this.offset += 4;
-        return value;
-    }
-    /**
-     * Read a 32-bit unsigned integer and move pointer forward by 4 bytes.
-     */
-    readUint32() {
-        const value = this._data.getUint32(this.offset, this.littleEndian);
-        this.offset += 4;
-        return value;
-    }
-    /**
-     * Read a 32-bit floating number and move pointer forward by 4 bytes.
-     */
-    readFloat32() {
-        const value = this._data.getFloat32(this.offset, this.littleEndian);
-        this.offset += 4;
-        return value;
-    }
-    /**
-     * Read a 64-bit floating number and move pointer forward by 8 bytes.
-     */
-    readFloat64() {
-        const value = this._data.getFloat64(this.offset, this.littleEndian);
-        this.offset += 8;
-        return value;
-    }
-    /**
-     * Read a 1-byte ASCII character and move pointer forward by 1 byte.
-     */
-    readChar() {
-        return String.fromCharCode(this.readInt8());
-    }
-    /**
-     * Read `n` 1-byte ASCII characters and move pointer forward by `n` bytes.
-     */
-    readChars(n = 1) {
-        let result = '';
-        for (let i = 0; i < n; i++) {
-            result += this.readChar();
-        }
-        return result;
-    }
-    /**
-     * Read the next `n` bytes, return a UTF-8 decoded string and move pointer
-     * forward by `n` bytes.
-     */
-    readUtf8(n = 1) {
-        return this.textDecoder.decode(this.readBytes(n));
-    }
-    /**
-     * Write 0xff if the passed value is truthy, 0x00 otherwise and move pointer
-     * forward by 1 byte.
-     */
-    writeBoolean(value) {
-        this.writeUint8(value ? 0xff : 0x00);
-        return this;
-    }
-    /**
-     * Write `value` as an 8-bit signed integer and move pointer forward by 1 byte.
-     */
-    writeInt8(value) {
-        this.ensureAvailable(1);
-        this._data.setInt8(this.offset++, value);
-        this._updateLastWrittenByte();
-        return this;
-    }
-    /**
-     * Write `value` as an 8-bit unsigned integer and move pointer forward by 1
-     * byte.
-     */
-    writeUint8(value) {
-        this.ensureAvailable(1);
-        this._data.setUint8(this.offset++, value);
-        this._updateLastWrittenByte();
-        return this;
-    }
-    /**
-     * An alias for {@link IOBuffer#writeUint8}.
-     */
-    writeByte(value) {
-        return this.writeUint8(value);
-    }
-    /**
-     * Write all elements of `bytes` as uint8 values and move pointer forward by
-     * `bytes.length` bytes.
-     */
-    writeBytes(bytes) {
-        this.ensureAvailable(bytes.length);
-        for (let i = 0; i < bytes.length; i++) {
-            this._data.setUint8(this.offset++, bytes[i]);
-        }
-        this._updateLastWrittenByte();
-        return this;
-    }
-    /**
-     * Write `value` as a 16-bit signed integer and move pointer forward by 2
-     * bytes.
-     */
-    writeInt16(value) {
-        this.ensureAvailable(2);
-        this._data.setInt16(this.offset, value, this.littleEndian);
-        this.offset += 2;
-        this._updateLastWrittenByte();
-        return this;
-    }
-    /**
-     * Write `value` as a 16-bit unsigned integer and move pointer forward by 2
-     * bytes.
-     */
-    writeUint16(value) {
-        this.ensureAvailable(2);
-        this._data.setUint16(this.offset, value, this.littleEndian);
-        this.offset += 2;
-        this._updateLastWrittenByte();
-        return this;
-    }
-    /**
-     * Write `value` as a 32-bit signed integer and move pointer forward by 4
-     * bytes.
-     */
-    writeInt32(value) {
-        this.ensureAvailable(4);
-        this._data.setInt32(this.offset, value, this.littleEndian);
-        this.offset += 4;
-        this._updateLastWrittenByte();
-        return this;
-    }
-    /**
-     * Write `value` as a 32-bit unsigned integer and move pointer forward by 4
-     * bytes.
-     */
-    writeUint32(value) {
-        this.ensureAvailable(4);
-        this._data.setUint32(this.offset, value, this.littleEndian);
-        this.offset += 4;
-        this._updateLastWrittenByte();
-        return this;
-    }
-    /**
-     * Write `value` as a 32-bit floating number and move pointer forward by 4
-     * bytes.
-     */
-    writeFloat32(value) {
-        this.ensureAvailable(4);
-        this._data.setFloat32(this.offset, value, this.littleEndian);
-        this.offset += 4;
-        this._updateLastWrittenByte();
-        return this;
-    }
-    /**
-     * Write `value` as a 64-bit floating number and move pointer forward by 8
-     * bytes.
-     */
-    writeFloat64(value) {
-        this.ensureAvailable(8);
-        this._data.setFloat64(this.offset, value, this.littleEndian);
-        this.offset += 8;
-        this._updateLastWrittenByte();
-        return this;
-    }
-    /**
-     * Write the charCode of `str`'s first character as an 8-bit unsigned integer
-     * and move pointer forward by 1 byte.
-     */
-    writeChar(str) {
-        return this.writeUint8(str.charCodeAt(0));
-    }
-    /**
-     * Write the charCodes of all `str`'s characters as 8-bit unsigned integers
-     * and move pointer forward by `str.length` bytes.
-     */
-    writeChars(str) {
-        for (let i = 0; i < str.length; i++) {
-            this.writeUint8(str.charCodeAt(i));
-        }
-        return this;
-    }
-    /**
-     * UTF-8 encode and write `str` to the current pointer offset and move pointer
-     * forward according to the encoded length.
-     */
-    writeUtf8(str) {
-        const bytes = this.textEncoder.encode(str);
-        return this.writeBytes(bytes);
-    }
-    /**
-     * Export a Uint8Array view of the internal buffer.
-     * The view starts at the byte offset and its length
-     * is calculated to stop at the last written byte or the original length.
-     */
-    toArray() {
-        return new Uint8Array(this.buffer, this.byteOffset, this.lastWrittenByte);
-    }
-    /**
-     * Update the last written byte offset
-     * @private
-     */
-    _updateLastWrittenByte() {
-        if (this.offset > this.lastWrittenByte) {
-            this.lastWrittenByte = this.offset;
-        }
-    }
-}
-exports.IOBuffer = IOBuffer;

package/dist/netcdf-loader.js

@@ -1,52 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._typecheckNetCDFLoader = exports._typecheckNetCDFWorkerLoader = exports.NetCDFLoader = exports.NetCDFWorkerLoader = void 0;
-const netcdf_reader_1 = require("./netcdfjs/netcdf-reader");
-// __VERSION__ is injected by babel-plugin-version-inline
-// @ts-ignore TS2304: Cannot find name '__VERSION__'.
-const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
-/**
- * Worker loader for NETCDF
- */
-exports.NetCDFWorkerLoader = {
-    name: 'NetCDF',
-    id: 'mvt',
-    module: 'mvt',
-    version: VERSION,
-    extensions: ['cdf', 'nc'],
-    mimeTypes: [
-        'application/netcdf',
-        'application/x-netcdf'
-        // 'application/octet-stream'
-    ],
-    category: 'image',
-    options: {
-        netcdf: {
-            loadVariables: false
-        }
-    }
-};
-/**
- * Loader for the NetCDF format
- */
-exports.NetCDFLoader = {
-    ...exports.NetCDFWorkerLoader,
-    parse: async (arrayBuffer, options) => parseNetCDF(arrayBuffer, options),
-    binary: true
-};
-function parseNetCDF(arrayBuffer, options) {
-    const reader = new netcdf_reader_1.NetCDFReader(arrayBuffer);
-    const variables = {};
-    if (options?.netcdf?.loadData) {
-        for (const variable of reader.variables) {
-            variables[variable.name] = reader.getDataVariable(variable);
-        }
-    }
-    return {
-        loaderData: reader.header,
-        data: variables
-    };
-}
-// Type tests
-exports._typecheckNetCDFWorkerLoader = exports.NetCDFWorkerLoader;
-exports._typecheckNetCDFLoader = exports.NetCDFLoader;

package/dist/netcdfjs/netcdf-reader.js

@@ -1,165 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NetCDFReader = void 0;
-const iobuffer_1 = require("../iobuffer/iobuffer");
-const read_header_1 = require("./read-header");
-const read_data_1 = require("./read-data");
-/**
- * Reads a NetCDF v3.x file
- * https://www.unidata.ucar.edu/software/netcdf/docs/file_format_specifications.html
- * @param {ArrayBuffer} data - ArrayBuffer or any Typed Array (including Node.js' Buffer from v4) with the data
- * @constructor
- */
-class NetCDFReader {
-    constructor(data) {
-        const buffer = new iobuffer_1.IOBuffer(data);
-        buffer.setBigEndian();
-        // Validate that it's a NetCDF file
-        const magic = buffer.readChars(3);
-        if (magic !== 'CDF') {
-            throw new Error(`NetCDF: file should start with 'CDF', found ${magic}`);
-        }
-        // Check the NetCDF format
-        const version = buffer.readByte();
-        if (version > 2) {
-            throw new Error(`NetCDF: unsupported version ${version}`);
-        }
-        // Read the header
-        this.header = (0, read_header_1.readNetCDFHeader)(buffer, version);
-        this.buffer = buffer;
-    }
-    /**
-     * @return {string} - Version for the NetCDF format
-     */
-    get version() {
-        if (this.header.version === 1) {
-            return 'classic format';
-        }
-        return '64-bit offset format';
-    }
-    /**
-     * Get metadata for the record dimension
-     */
-    get recordDimension() {
-        return this.header.recordDimension;
-    }
-    /**
-     * Get list of dimensions (each with `name` and `size`)
-     */
-    get dimensions() {
-        return this.header.dimensions;
-    }
-    /**
-     * Get list of global attributes with:
-     *  * `name`: String with the name of the attribute
-     *  * `type`: String with the type of the attribute
-     *  * `value`: A number or string with the value of the attribute
-     */
-    get attributes() {
-        return this.header.attributes;
-    }
-    /**
-     * Get list of variables
-     */
-    get variables() {
-        return this.header.variables;
-    }
-    /**
-     * Check if an attribute exists
-     * @param attributeName - Name of the attribute to find
-     * @return
-     */
-    attributeExists(attributeName) {
-        const attribute = this.attributes.find((val) => val.name === attributeName);
-        return attribute !== undefined;
-    }
-    /**
-     * Returns the value of an attribute
-     * @param attributeName
-     * @return Value of the attributeName or null
-     */
-    getAttribute(attributeName) {
-        const attribute = this.attributes.find((val) => val.name === attributeName);
-        if (attribute)
-            return attribute.value;
-        return null;
-    }
-    /**
-     * Check if a dataVariable exists
-     * @param variableName - Name of the variable to find
-     * @return
-     */
-    dataVariableExists(variableName) {
-        const variable = this.header.variables.find(function (val) {
-            return val.name === variableName;
-        });
-        return variable !== undefined;
-    }
-    /**
-     * Returns the value of a variable as a string
-     * @param variableName
-     * @return Value of the variable as a string or null
-     */
-    getDataVariableAsString(variableName) {
-        const variable = this.getDataVariable(variableName);
-        if (variable)
-            return variable.join('');
-        return null;
-    }
-    /**
-     * Retrieves the data for a given variable
-     * @param variableName - Name of the variable to search or variable object
-     * @return List with the variable values
-     */
-    getDataVariable(variableName) {
-        let variable;
-        if (typeof variableName === 'string') {
-            // search the variable
-            variable = this.header.variables.find(function (val) {
-                return val.name === variableName;
-            });
-        }
-        else {
-            variable = variableName;
-        }
-        // throws if variable not found
-        if (variable === undefined) {
-            throw new Error(`NetCDF: variable not found: ${variableName}`);
-        }
-        // go to the offset position
-        this.buffer.seek(variable.offset);
-        if (variable.record) {
-            // record variable case
-            return (0, read_data_1.readRecord)(this.buffer, variable, this.header.recordDimension);
-        }
-        // non-record variable case
-        return (0, read_data_1.readNonRecord)(this.buffer, variable);
-    }
-    toString() {
-        const result = [];
-        result.push('DIMENSIONS');
-        for (const dimension of this.dimensions) {
-            result.push(`  ${dimension.name.padEnd(30)} = size: ${dimension.size}`);
-        }
-        result.push('');
-        result.push('GLOBAL ATTRIBUTES');
-        for (const attribute of this.attributes) {
-            result.push(`  ${attribute.name.padEnd(30)} = ${attribute.value}`);
-        }
-        const variables = JSON.parse(JSON.stringify(this.variables));
-        result.push('');
-        result.push('VARIABLES:');
-        for (const variable of variables) {
-            variable.value = this.getDataVariable(variable);
-            let stringify = JSON.stringify(variable.value);
-            if (stringify.length > 50)
-                stringify = stringify.substring(0, 50);
-            if (!isNaN(variable.value.length)) {
-                stringify += ` (length: ${variable.value.length})`;
-            }
-            result.push(`  ${variable.name.padEnd(30)} = ${stringify}`);
-        }
-        return result.join('\n');
-    }
-}
-exports.NetCDFReader = NetCDFReader;

package/dist/netcdfjs/netcdf-types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/netcdfjs/read-data.js

@@ -1,49 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.readRecord = exports.readNonRecord = void 0;
-const read_type_1 = require("./read-type");
-// const STREAMING = 4294967295;
-/**
- * Read data for the given non-record variable
- * @param buffer - Buffer for the file data
- * @param variable - Variable metadata
- * @return Data of the element
- */
-function readNonRecord(buffer, variable) {
-    // variable type
-    const type = (0, read_type_1.str2num)(variable.type);
-    // size of the data
-    const size = variable.size / (0, read_type_1.num2bytes)(type);
-    // iterates over the data
-    const data = new Array(size);
-    for (let i = 0; i < size; i++) {
-        data[i] = (0, read_type_1.readType)(buffer, type, 1);
-    }
-    return data;
-}
-exports.readNonRecord = readNonRecord;
-/**
- * Read data for the given record variable
- * @param buffer - Buffer for the file data
- * @param variable - Variable metadata
- * @param recordDimension - Record dimension metadata
- * @return - Data of the element
- */
-function readRecord(buffer, variable, recordDimension) {
-    // variable type
-    const type = (0, read_type_1.str2num)(variable.type);
-    const width = variable.size ? variable.size / (0, read_type_1.num2bytes)(type) : 1;
-    // size of the data
-    // TODO streaming data
-    const size = recordDimension.length;
-    // iterates over the data
-    const data = new Array(size);
-    const step = recordDimension.recordStep;
-    for (let i = 0; i < size; i++) {
-        const currentOffset = buffer.offset;
-        data[i] = (0, read_type_1.readType)(buffer, type, width);
-        buffer.seek(currentOffset + step);
-    }
-    return data;
-}
-exports.readRecord = readRecord;

package/dist/netcdfjs/read-header.js

@@ -1,230 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.readName = exports.readNetCDFHeader = void 0;
-const read_type_1 = require("./read-type");
-// Grammar constants
-const ZERO = 0;
-const NC_DIMENSION = 10;
-const NC_VARIABLE = 11;
-const NC_ATTRIBUTE = 12;
-const NC_UNLIMITED = 0;
-/**
- * Read the header of the file
- * @param buffer - Buffer for the file data
- * @param version - Version of the file
- * @return  - Header
- */
-function readNetCDFHeader(buffer, version) {
-    // Length of record dimension
-    // sum of the varSize's of all the record variables.
-    const recordDimensionLength = buffer.readUint32();
-    // List of dimensions
-    const dimList = readDimensionsList(buffer);
-    // List of global attributes
-    const attributes = readAttributesList(buffer);
-    // List of variables
-    const variableList = readVariablesList(buffer, dimList.recordId, version);
-    const header = {
-        version,
-        recordDimension: {
-            length: recordDimensionLength,
-            id: dimList.recordId,
-            name: dimList.recordName,
-            recordStep: variableList.recordStep
-        },
-        dimensions: dimList.dimensions,
-        variables: variableList.variables,
-        attributes
-    };
-    return header;
-}
-exports.readNetCDFHeader = readNetCDFHeader;
-/**
- * Read list of dimensions
- * @ignore
- * @param {IOBuffer} buffer - Buffer for the file data
- */
-function readDimensionsList(buffer) {
-    const dimList = buffer.readUint32();
-    if (dimList === ZERO) {
-        if (buffer.readUint32() !== ZERO) {
-            throw new Error('NetCDF: wrong empty tag for list of dimensions');
-        }
-        // TODO - is this empty dimension list supported / recoverable?
-        return {
-            recordId: 0,
-            recordName: '',
-            dimensions: []
-        };
-    }
-    if (dimList !== NC_DIMENSION) {
-        throw new Error('NetCDF: wrong tag for list of dimensions');
-    }
-    // Length of dimensions
-    const dimensionSize = buffer.readUint32();
-    const dimensions = new Array(dimensionSize);
-    let recordId;
-    let recordName;
-    for (let dim = 0; dim < dimensionSize; dim++) {
-        // Read name
-        const name = readName(buffer);
-        // Read dimension size
-        const size = buffer.readUint32();
-        if (size === NC_UNLIMITED) {
-            // in netcdf 3 one field can be of size unlimmited
-            recordId = dim;
-            recordName = name;
-        }
-        dimensions[dim] = {
-            name,
-            size
-        };
-    }
-    return {
-        dimensions,
-        recordId,
-        recordName
-    };
-}
-/**
- * List of attributes
- * @ignore
- * @param buffer - Buffer for the file data
- * @return List of attributes with:
- */
-function readAttributesList(buffer) {
-    const gAttList = buffer.readUint32();
-    if (gAttList === ZERO) {
-        if (buffer.readUint32() !== ZERO) {
-            throw new Error('NetCDF: wrong empty tag for list of attributes');
-        }
-        return [];
-    }
-    if (gAttList !== NC_ATTRIBUTE) {
-        throw new Error('NetCDF: wrong tag for list of attributes');
-    }
-    // Length of attributes
-    const attributeSize = buffer.readUint32();
-    const attributes = new Array(attributeSize);
-    for (let gAtt = 0; gAtt < attributeSize; gAtt++) {
-        // Read name
-        const name = readName(buffer);
-        // Read type
-        const type = buffer.readUint32();
-        if (type < 1 || type > 6) {
-            throw new Error(`NetCDF: non valid type ${type}`);
-        }
-        // Read attribute
-        const size = buffer.readUint32();
-        const value = (0, read_type_1.readType)(buffer, type, size);
-        // Apply padding
-        padding(buffer);
-        attributes[gAtt] = {
-            name,
-            type: (0, read_type_1.num2str)(type),
-            value
-        };
-    }
-    return attributes;
-}
-/**
- * List of variables
- * @param buffer - Buffer for the file data
- * @param recordId - Id of the unlimited dimension (also called record dimension)
- *                            This value may be undefined if there is no unlimited dimension
- * @param {number} version - Version of the file
- */
-// eslint-disable-next-line max-statements, complexity
-function readVariablesList(buffer, recordId, version) {
-    const varList = buffer.readUint32();
-    let recordStep = 0;
-    if (varList === ZERO) {
-        if (buffer.readUint32() !== ZERO) {
-            throw new Error('NetCDF: wrong empty tag for list of variables');
-        }
-        return {
-            recordStep,
-            variables: []
-        };
-    }
-    if (varList !== NC_VARIABLE) {
-        throw new Error('NetCDF: wrong tag for list of variables');
-    }
-    // Length of variables
-    const variableSize = buffer.readUint32();
-    const variables = new Array(variableSize);
-    for (let v = 0; v < variableSize; v++) {
-        // Read name
-        const name = readName(buffer);
-        // Read dimensionality of the variable
-        const dimensionality = buffer.readUint32();
-        // Index into the list of dimensions
-        const dimensionsIds = new Array(dimensionality);
-        for (let dim = 0; dim < dimensionality; dim++) {
-            dimensionsIds[dim] = buffer.readUint32();
-        }
-        // Read variables size
-        const attributes = readAttributesList(buffer);
-        // Read type
-        const type = buffer.readUint32();
-        if (type < 1 && type > 6) {
-            throw new Error(`NetCDF: non valid type ${type}`);
-        }
-        // Read variable size
-        // The 32-bit varSize field is not large enough to contain the size of variables that require
-        // more than 2^32 - 4 bytes, so 2^32 - 1 is used in the varSize field for such variables.
-        const varSize = buffer.readUint32();
-        // Read offset
-        let offset = buffer.readUint32();
-        if (version === 2) {
-            if (offset > 0) {
-                throw new Error('NetCDF: offsets larger than 4GB not supported');
-            }
-            offset = buffer.readUint32();
-        }
-        let record = false;
-        // Count amount of record variables
-        if (typeof recordId !== 'undefined' && dimensionsIds[0] === recordId) {
-            recordStep += varSize;
-            record = true;
-        }
-        variables[v] = {
-            name,
-            dimensions: dimensionsIds,
-            attributes,
-            type: (0, read_type_1.num2str)(type),
-            size: varSize,
-            offset,
-            record
-        };
-    }
-    return {
-        variables,
-        recordStep
-    };
-}
-// HELPERS
-/**
- * Reads the name
- * @param buffer - Buffer for the file data
- * @return Name
- */
-function readName(buffer) {
-    // Read name
-    const nameLength = buffer.readUint32();
-    const name = buffer.readChars(nameLength);
-    // validate name
-    // TODO
-    // Apply padding
-    padding(buffer);
-    return name;
-}
-exports.readName = readName;
-/**
- * Moves 1, 2, or 3 bytes to next 4-byte boundary
- */
-function padding(buffer) {
-    if (buffer.offset % 4 !== 0) {
-        buffer.skip(4 - (buffer.offset % 4));
-    }
-}

package/dist/netcdfjs/read-type.js

@@ -1,140 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.str2num = exports.num2bytes = exports.num2str = exports.readType = exports.TYPES = void 0;
-exports.TYPES = {
-    BYTE: 1,
-    CHAR: 2,
-    SHORT: 3,
-    INT: 4,
-    FLOAT: 5,
-    DOUBLE: 6
-};
-/**
- * Given a type and a size reads the next element
- * @param buffer - Buffer for the file data
- * @param type - Type of the data to read
- * @param size - Size of the element to read
- * @return
- */
-function readType(buffer, type, size) {
-    switch (type) {
-        case exports.TYPES.BYTE:
-            return buffer.readBytes(size);
-        case exports.TYPES.CHAR:
-            return trimNull(buffer.readChars(size));
-        case exports.TYPES.SHORT:
-            return readNumber(size, buffer.readInt16.bind(buffer));
-        case exports.TYPES.INT:
-            return readNumber(size, buffer.readInt32.bind(buffer));
-        case exports.TYPES.FLOAT:
-            return readNumber(size, buffer.readFloat32.bind(buffer));
-        case exports.TYPES.DOUBLE:
-            return readNumber(size, buffer.readFloat64.bind(buffer));
-        /* istanbul ignore next */
-        default:
-            throw new Error(`NetCDF: non valid type ${type}`);
-    }
-}
-exports.readType = readType;
-/**
- * Parse a number into their respective type
- * @param type - integer that represents the type
- * @return parsed value of the type
- */
-function num2str(type) {
-    switch (Number(type)) {
-        case exports.TYPES.BYTE:
-            return 'byte';
-        case exports.TYPES.CHAR:
-            return 'char';
-        case exports.TYPES.SHORT:
-            return 'short';
-        case exports.TYPES.INT:
-            return 'int';
-        case exports.TYPES.FLOAT:
-            return 'float';
-        case exports.TYPES.DOUBLE:
-            return 'double';
-        /* istanbul ignore next */
-        default:
-            return 'undefined';
-    }
-}
-exports.num2str = num2str;
-/**
- * Parse a number type identifier to his size in bytes
- * @param type - integer that represents the type
- * @return size of the type
- */
-function num2bytes(type) {
-    switch (Number(type)) {
-        case exports.TYPES.BYTE:
-            return 1;
-        case exports.TYPES.CHAR:
-            return 1;
-        case exports.TYPES.SHORT:
-            return 2;
-        case exports.TYPES.INT:
-            return 4;
-        case exports.TYPES.FLOAT:
-            return 4;
-        case exports.TYPES.DOUBLE:
-            return 8;
-        /* istanbul ignore next */
-        default:
-            return -1;
-    }
-}
-exports.num2bytes = num2bytes;
-/**
- * Reverse search of num2str
- * @param type string that represents the type
- * @return parsed value of the type
- */
-function str2num(type) {
-    switch (String(type)) {
-        case 'byte':
-            return exports.TYPES.BYTE;
-        case 'char':
-            return exports.TYPES.CHAR;
-        case 'short':
-            return exports.TYPES.SHORT;
-        case 'int':
-            return exports.TYPES.INT;
-        case 'float':
-            return exports.TYPES.FLOAT;
-        case 'double':
-            return exports.TYPES.DOUBLE;
-        /* istanbul ignore next */
-        default:
-            return -1;
-    }
-}
-exports.str2num = str2num;
-/**
- * Auxiliary function to read numeric data
- * @param size - Size of the element to read
- * @param bufferReader - Function to read next value
- * @return
- */
-function readNumber(size, bufferReader) {
-    if (size !== 1) {
-        const numbers = new Array(size);
-        for (let i = 0; i < size; i++) {
-            numbers[i] = bufferReader();
-        }
-        return numbers;
-    }
-    return bufferReader();
-}
-/**
- * Removes null terminate value
- * @param value - String to trim
- * @return - Trimmed string
- */
-function trimNull(value) {
-    if (value.charCodeAt(value.length - 1) === 0) {
-        return value.substring(0, value.length - 1);
-    }
-    return value;
-}