xm-netcdf-loader 1.0.0

package/dist/netcdf4-wasm/dist/constants.d.ts

@@ -0,0 +1,158 @@
+export declare const NC_CONSTANTS: {
+    NC_NOERR: number;
+    NC_EBADID: number;
+    NC_ENFILE: number;
+    NC_EEXIST: number;
+    NC_EINVAL: number;
+    NC_EPERM: number;
+    NC_ENOTINDEFINE: number;
+    NC_EINDEFINE: number;
+    NC_EINVALCOORDS: number;
+    NC_EMAXDIMS: number;
+    NC_ENAMEINUSE: number;
+    NC_ENOTATT: number;
+    NC_EMAXATTS: number;
+    NC_EBADTYPE: number;
+    NC_EBADDIM: number;
+    NC_EUNLIMPOS: number;
+    NC_EMAXVARS: number;
+    NC_ENOTVAR: number;
+    NC_EGLOBAL: number;
+    NC_ENOTNC: number;
+    NC_ESTS: number;
+    NC_EMAXNAME: number;
+    NC_EUNLIMIT: number;
+    NC_ENORECVARS: number;
+    NC_ECHAR: number;
+    NC_EEDGE: number;
+    NC_ESTRIDE: number;
+    NC_EBADNAME: number;
+    NC_ERANGE: number;
+    NC_ENOMEM: number;
+    NC_EVARSIZE: number;
+    NC_EDIMSIZE: number;
+    NC_ETRUNC: number;
+    NC_EAXISTYPE: number;
+    NC_EDAP: number;
+    NC_ECURL: number;
+    NC_EIO: number;
+    NC_ENODATA: number;
+    NC_EDAPSVC: number;
+    NC_EDAS: number;
+    NC_EDDS: number;
+    NC_EDATADDS: number;
+    NC_EDAPURL: number;
+    NC_EDAPCONSTRAINT: number;
+    NC_ETRANSLATION: number;
+    NC_EACCESS: number;
+    NC_EAUTH: number;
+    NC_ENOTFOUND: number;
+    NC_ECANTREMOVE: number;
+    NC_EINTERNAL: number;
+    NC_EPNETCDF: number;
+    NC_EHDFERR: number;
+    NC_ECANTREAD: number;
+    NC_ECANTWRITE: number;
+    NC_ECANTCREATE: number;
+    NC_EFILEMETA: number;
+    NC_EDIMMETA: number;
+    NC_EATTMETA: number;
+    NC_EVARMETA: number;
+    NC_ENOCOMPOUND: number;
+    NC_EATTEXISTS: number;
+    NC_ENOTNC4: number;
+    NC_ESTRICTNC3: number;
+    NC_ENOTNC3: number;
+    NC_ENOPAR: number;
+    NC_EPARINIT: number;
+    NC_EBADGRPID: number;
+    NC_EBADTYPID: number;
+    NC_ETYPDEFINED: number;
+    NC_EBADFIELD: number;
+    NC_EBADCLASS: number;
+    NC_EMAPTYPE: number;
+    NC_ELATEFILL: number;
+    NC_ELATEDEF: number;
+    NC_EDIMSCALE: number;
+    NC_ENOGRP: number;
+    NC_ESTORAGE: number;
+    NC_EBADCHUNK: number;
+    NC_ENOTBUILT: number;
+    NC_EDISKLESS: number;
+    NC_ECANTEXTEND: number;
+    NC_EMPI: number;
+    NC_NOWRITE: number;
+    NC_WRITE: number;
+    NC_CLOBBER: number;
+    NC_NOCLOBBER: number;
+    NC_DISKLESS: number;
+    NC_MMAP: number;
+    NC_64BIT_DATA: number;
+    NC_CDF5: number;
+    NC_CLASSIC_MODEL: number;
+    NC_64BIT_OFFSET: number;
+    NC_NETCDF4: number;
+    NC_SHARE: number;
+    NC_INMEMORY: number;
+    NC_FORMAT_CLASSIC: number;
+    NC_FORMAT_64BIT_OFFSET: number;
+    NC_FORMAT_64BIT: number;
+    NC_FORMAT_NETCDF4: number;
+    NC_FORMAT_NETCDF4_CLASSIC: number;
+    NC_FORMAT_64BIT_DATA: number;
+    NC_FORMAT_CDF5: number;
+    NC_NAT: number;
+    NC_BYTE: number;
+    NC_CHAR: number;
+    NC_SHORT: number;
+    NC_INT: number;
+    NC_LONG: number;
+    NC_FLOAT: number;
+    NC_DOUBLE: number;
+    NC_UBYTE: number;
+    NC_USHORT: number;
+    NC_UINT: number;
+    NC_INT64: number;
+    NC_UINT64: number;
+    NC_STRING: number;
+    NC_LONGLONG: number;
+    NC_ULONGLONG: number;
+    NC_VLEN: number;
+    NC_OPAQUE: number;
+    NC_ENUM: number;
+    NC_COMPOUND: number;
+    NC_FIRSTUSERTYPEID: number;
+    NC_FILL: number;
+    NC_NOFILL: number;
+    NC_CHUNKED: number;
+    NC_CONTIGUOUS: number;
+    NC_COMPACT: number;
+    NC_VIRTUAL: number;
+    NC_ENDIAN_NATIVE: number;
+    NC_ENDIAN_LITTLE: number;
+    NC_ENDIAN_BIG: number;
+    NC_UNLIMITED: number;
+    NC_GLOBAL: number;
+    NC_MAX_DIMS: number;
+    NC_MAX_ATTRS: number;
+    NC_MAX_VARS: number;
+    NC_MAX_NAME: number;
+    NC_MAX_VAR_DIMS: number;
+    NC_NOCHECKSUM: number;
+    NC_FLETCHER32: number;
+    NC_NOSHUFFLE: number;
+    NC_SHUFFLE: number;
+};
+export declare const DATA_TYPE_MAP: {
+    [key: string]: number;
+};
+export declare const CONSTANT_DTYPE_MAP: {
+    [key: number]: string;
+};
+export declare const DATA_TYPE_SIZE: {
+    [key: number]: number;
+};
+export declare const TYPE_NAMES: {
+    [key: number]: string;
+};
+//# sourceMappingURL=constants.d.ts.map

package/dist/netcdf4-wasm/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6KxB,CAAC;AAGF,eAAO,MAAM,aAAa,EAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;CAiClD,CAAC;AAGF,eAAO,MAAM,kBAAkB,EAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;CAcvD,CAAC;AAGF,eAAO,MAAM,cAAc,EAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;CAcnD,CAAC;AAGF,eAAO,MAAM,UAAU,EAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;CAkB/C,CAAC"}

package/dist/netcdf4-wasm/dist/constants.js

@@ -0,0 +1,249 @@
+// NetCDF4 constants (populated from NetCDF4 headers)
+// see: https://github.com/Unidata/netcdf-c/blob/main/include/netcdf.h
+// https://docs.unidata.ucar.edu/netcdf-c/current/nc-error-codes.html
+export const NC_CONSTANTS = {
+    // Error codes
+    NC_NOERR: 0,
+    NC_EBADID: -33,
+    NC_ENFILE: -34,
+    NC_EEXIST: -35,
+    NC_EINVAL: -36,
+    NC_EPERM: -37,
+    NC_ENOTINDEFINE: -38,
+    NC_EINDEFINE: -39,
+    NC_EINVALCOORDS: -40,
+    NC_EMAXDIMS: -41,
+    NC_ENAMEINUSE: -42,
+    NC_ENOTATT: -43,
+    NC_EMAXATTS: -44,
+    NC_EBADTYPE: -45,
+    NC_EBADDIM: -46,
+    NC_EUNLIMPOS: -47,
+    NC_EMAXVARS: -48,
+    NC_ENOTVAR: -49,
+    NC_EGLOBAL: -50,
+    NC_ENOTNC: -51,
+    NC_ESTS: -52,
+    NC_EMAXNAME: -53,
+    NC_EUNLIMIT: -54,
+    NC_ENORECVARS: -55,
+    NC_ECHAR: -56,
+    NC_EEDGE: -57,
+    NC_ESTRIDE: -58,
+    NC_EBADNAME: -59,
+    NC_ERANGE: -60,
+    NC_ENOMEM: -61,
+    NC_EVARSIZE: -62,
+    NC_EDIMSIZE: -63,
+    NC_ETRUNC: -64,
+    NC_EAXISTYPE: -65,
+    // NetCDF-4 error codes
+    NC_EDAP: -66,
+    NC_ECURL: -67,
+    NC_EIO: -68,
+    NC_ENODATA: -69,
+    NC_EDAPSVC: -70,
+    NC_EDAS: -71,
+    NC_EDDS: -72,
+    NC_EDATADDS: -73,
+    NC_EDAPURL: -74,
+    NC_EDAPCONSTRAINT: -75,
+    NC_ETRANSLATION: -76,
+    NC_EACCESS: -77,
+    NC_EAUTH: -78,
+    NC_ENOTFOUND: -90,
+    NC_ECANTREMOVE: -91,
+    NC_EINTERNAL: -92, // internal library error
+    NC_EPNETCDF: -93, // PnetCDF error
+    NC_EHDFERR: -101,
+    NC_ECANTREAD: -102,
+    NC_ECANTWRITE: -103,
+    NC_ECANTCREATE: -104,
+    NC_EFILEMETA: -105,
+    NC_EDIMMETA: -106,
+    NC_EATTMETA: -107,
+    NC_EVARMETA: -108,
+    NC_ENOCOMPOUND: -109,
+    NC_EATTEXISTS: -110,
+    NC_ENOTNC4: -111,
+    NC_ESTRICTNC3: -112,
+    NC_ENOTNC3: -113,
+    NC_ENOPAR: -114,
+    NC_EPARINIT: -115,
+    NC_EBADGRPID: -116,
+    NC_EBADTYPID: -117,
+    NC_ETYPDEFINED: -118,
+    NC_EBADFIELD: -119,
+    NC_EBADCLASS: -120,
+    NC_EMAPTYPE: -121,
+    NC_ELATEFILL: -122,
+    NC_ELATEDEF: -123,
+    NC_EDIMSCALE: -124,
+    NC_ENOGRP: -125,
+    NC_ESTORAGE: -126,
+    NC_EBADCHUNK: -127,
+    NC_ENOTBUILT: -128,
+    NC_EDISKLESS: -129,
+    NC_ECANTEXTEND: -130,
+    NC_EMPI: -131,
+    // File modes
+    NC_NOWRITE: 0x0000,
+    NC_WRITE: 0x0001,
+    NC_CLOBBER: 0x0000,
+    NC_NOCLOBBER: 0x0004,
+    NC_DISKLESS: 0x0008,
+    NC_MMAP: 0x0010, // deprecated
+    NC_64BIT_DATA: 0x0020,
+    NC_CDF5: 0x0020,
+    NC_CLASSIC_MODEL: 0x0100,
+    NC_64BIT_OFFSET: 0x0200,
+    NC_NETCDF4: 0x1000,
+    NC_SHARE: 0x0800,
+    NC_INMEMORY: 0x8000,
+    // Format versions
+    NC_FORMAT_CLASSIC: 1,
+    NC_FORMAT_64BIT_OFFSET: 2,
+    NC_FORMAT_64BIT: 2,
+    NC_FORMAT_NETCDF4: 3,
+    NC_FORMAT_NETCDF4_CLASSIC: 4,
+    NC_FORMAT_64BIT_DATA: 5,
+    NC_FORMAT_CDF5: 5,
+    // Data types (atomic types)
+    NC_NAT: 0, // Not A Type
+    NC_BYTE: 1, // signed 1-byte integer
+    NC_CHAR: 2, // text character
+    NC_SHORT: 3, // signed 2-byte integer
+    NC_INT: 4, // signed 4-byte integer
+    NC_LONG: 4, // deprecated, same as NC_INT
+    NC_FLOAT: 5, // single precision float
+    NC_DOUBLE: 6, // double precision float
+    NC_UBYTE: 7, // unsigned 1-byte integer
+    NC_USHORT: 8, // unsigned 2-byte integer
+    NC_UINT: 9, // unsigned 4-byte integer
+    NC_INT64: 10, // signed 8-byte integer
+    NC_UINT64: 11, // unsigned 8-byte integer
+    NC_STRING: 12, // variable-length string
+    // Aliases for 64-bit integers
+    NC_LONGLONG: 10, // alias for NC_INT64
+    NC_ULONGLONG: 11, // alias for NC_UINT64
+    // User-defined types (NetCDF-4)
+    NC_VLEN: 13, // variable-length type
+    NC_OPAQUE: 14, // opaque type
+    NC_ENUM: 15, // enumeration type
+    NC_COMPOUND: 16, // compound type
+    // First user-defined type ID
+    NC_FIRSTUSERTYPEID: 32,
+    // Fill modes
+    NC_FILL: 0,
+    NC_NOFILL: 0x100,
+    // Storage types
+    NC_CHUNKED: 0,
+    NC_CONTIGUOUS: 1,
+    NC_COMPACT: 2,
+    NC_VIRTUAL: 3,
+    // Endianness
+    NC_ENDIAN_NATIVE: 0,
+    NC_ENDIAN_LITTLE: 1,
+    NC_ENDIAN_BIG: 2,
+    // Unlimited dimension
+    NC_UNLIMITED: 0,
+    // Special values
+    NC_GLOBAL: -1, // Global attribute
+    NC_MAX_DIMS: 1024,
+    NC_MAX_ATTRS: 8192,
+    NC_MAX_VARS: 8192,
+    NC_MAX_NAME: 256,
+    NC_MAX_VAR_DIMS: 1024,
+    // Compression
+    NC_NOCHECKSUM: 0,
+    NC_FLETCHER32: 1,
+    // Shuffle filter
+    NC_NOSHUFFLE: 0,
+    NC_SHUFFLE: 1,
+};
+// Data type mapping from string names to NetCDF constants
+export const DATA_TYPE_MAP = {
+    // Short names
+    'f8': NC_CONSTANTS.NC_DOUBLE,
+    'f4': NC_CONSTANTS.NC_FLOAT,
+    'i8': NC_CONSTANTS.NC_INT64,
+    'i4': NC_CONSTANTS.NC_INT,
+    'i2': NC_CONSTANTS.NC_SHORT,
+    'i1': NC_CONSTANTS.NC_BYTE,
+    'u8': NC_CONSTANTS.NC_UINT64,
+    'u4': NC_CONSTANTS.NC_UINT,
+    'u2': NC_CONSTANTS.NC_USHORT,
+    'u1': NC_CONSTANTS.NC_UBYTE,
+    'S1': NC_CONSTANTS.NC_CHAR,
+    // Long names
+    'double': NC_CONSTANTS.NC_DOUBLE,
+    'float': NC_CONSTANTS.NC_FLOAT,
+    'int64': NC_CONSTANTS.NC_INT64,
+    'int': NC_CONSTANTS.NC_INT,
+    'short': NC_CONSTANTS.NC_SHORT,
+    'byte': NC_CONSTANTS.NC_BYTE,
+    'uint64': NC_CONSTANTS.NC_UINT64,
+    'uint': NC_CONSTANTS.NC_UINT,
+    'ushort': NC_CONSTANTS.NC_USHORT,
+    'ubyte': NC_CONSTANTS.NC_UBYTE,
+    'char': NC_CONSTANTS.NC_CHAR,
+    'string': NC_CONSTANTS.NC_STRING,
+    'str': NC_CONSTANTS.NC_STRING,
+    // Aliases
+    'longlong': NC_CONSTANTS.NC_LONGLONG,
+    'ulonglong': NC_CONSTANTS.NC_ULONGLONG,
+    'long': NC_CONSTANTS.NC_INT,
+};
+// Reverse mapping: NetCDF type ID to dtype string
+export const CONSTANT_DTYPE_MAP = {
+    0: 'NAT', // NC_NAT
+    1: 'i1', // NC_BYTE
+    2: 'S1', // NC_CHAR
+    3: 'i2', // NC_SHORT
+    4: 'i4', // NC_INT
+    5: 'f4', // NC_FLOAT
+    6: 'f8', // NC_DOUBLE
+    7: 'u1', // NC_UBYTE
+    8: 'u2', // NC_USHORT
+    9: 'u4', // NC_UINT
+    10: 'i8', // NC_INT64
+    11: 'u8', // NC_UINT64
+    12: 'str', // NC_STRING
+};
+// Data type sizes in bytes
+export const DATA_TYPE_SIZE = {
+    0: 0, // NC_NAT
+    1: 1, // NC_BYTE
+    2: 1, // NC_CHAR
+    3: 2, // NC_SHORT
+    4: 4, // NC_INT
+    5: 4, // NC_FLOAT
+    6: 8, // NC_DOUBLE
+    7: 1, // NC_UBYTE
+    8: 2, // NC_USHORT
+    9: 4, // NC_UINT
+    10: 8, // NC_INT64
+    11: 8, // NC_UINT64
+    12: 0, // NC_STRING (variable length)
+};
+// Human-readable type names
+export const TYPE_NAMES = {
+    0: 'NAT',
+    1: 'byte',
+    2: 'char',
+    3: 'short',
+    4: 'int',
+    5: 'float',
+    6: 'double',
+    7: 'ubyte',
+    8: 'ushort',
+    9: 'uint',
+    10: 'int64',
+    11: 'uint64',
+    12: 'string',
+    13: 'vlen',
+    14: 'opaque',
+    15: 'enum',
+    16: 'compound',
+};
+//# sourceMappingURL=constants.js.map

package/dist/netcdf4-wasm/dist/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"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"}

package/dist/netcdf4-wasm/dist/dimension.d.ts

@@ -0,0 +1,9 @@
+export declare class Dimension {
+    readonly name: string;
+    readonly size: number;
+    readonly isUnlimited: boolean;
+    constructor(name: string, size: number, isUnlimited?: boolean);
+    __len__(): number;
+    toString(): string;
+}
+//# sourceMappingURL=dimension.d.ts.map

package/dist/netcdf4-wasm/dist/dimension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dimension.d.ts","sourceRoot":"","sources":["../src/dimension.ts"],"names":[],"mappings":"AAEA,qBAAa,SAAS;aAEE,IAAI,EAAE,MAAM;aACZ,IAAI,EAAE,MAAM;aACZ,WAAW,EAAE,OAAO;gBAFpB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,WAAW,GAAE,OAAe;IAGhD,OAAO,IAAI,MAAM;IAIjB,QAAQ,IAAI,MAAM;CAIrB"}

package/dist/netcdf4-wasm/dist/dimension.js

@@ -0,0 +1,19 @@
+// Dimension class similar to netcdf4-python
+export class Dimension {
+    name;
+    size;
+    isUnlimited;
+    constructor(name, size, isUnlimited = false) {
+        this.name = name;
+        this.size = size;
+        this.isUnlimited = isUnlimited;
+    }
+    __len__() {
+        return this.size;
+    }
+    toString() {
+        const sizeStr = this.isUnlimited ? 'unlimited' : this.size.toString();
+        return `<netCDF4.Dimension '${this.name}': size = ${sizeStr}>`;
+    }
+}
+//# sourceMappingURL=dimension.js.map

package/dist/netcdf4-wasm/dist/dimension.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dimension.js","sourceRoot":"","sources":["../src/dimension.ts"],"names":[],"mappings":"AAAA,4CAA4C;AAE5C,MAAM,OAAO,SAAS;IAEE;IACA;IACA;IAHpB,YACoB,IAAY,EACZ,IAAY,EACZ,cAAuB,KAAK;QAF5B,SAAI,GAAJ,IAAI,CAAQ;QACZ,SAAI,GAAJ,IAAI,CAAQ;QACZ,gBAAW,GAAX,WAAW,CAAiB;IAC7C,CAAC;IAEJ,OAAO;QACH,OAAO,IAAI,CAAC,IAAI,CAAC;IACrB,CAAC;IAED,QAAQ;QACJ,MAAM,OAAO,GAAG,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;QACtE,OAAO,uBAAuB,IAAI,CAAC,IAAI,aAAa,OAAO,GAAG,CAAC;IACnE,CAAC;CACJ"}

package/dist/netcdf4-wasm/dist/group.d.ts

@@ -0,0 +1,35 @@
+import type { NetCDF4 } from './netcdf4.js';
+import { Dimension } from './dimension.js';
+import { Variable } from './variable.js';
+import type { VariableOptions } from './types.js';
+export declare class Group {
+    protected netcdf: NetCDF4;
+    readonly name: string;
+    protected groupId: number;
+    protected parent?: Group | undefined;
+    readonly dimensions: {
+        [name: string]: Dimension;
+    };
+    readonly variables: {
+        [name: string]: Variable;
+    };
+    readonly groups: {
+        [name: string]: Group;
+    };
+    private _attributes;
+    constructor(netcdf: NetCDF4, name: string, groupId: number, parent?: Group | undefined);
+    setAttr(name: string, value: any): void;
+    getAttr(name: string): any;
+    attrs(): string[];
+    createDimension(name: string, size: number | null): Promise<Dimension>;
+    loadMockDimensions(): void;
+    createVariable(name: string, datatype: string, dimensions?: string[], options?: VariableOptions): Promise<Variable>;
+    createGroup(name: string): Group;
+    children(): {
+        [name: string]: Group;
+    };
+    get path(): string;
+    load(): Promise<void>;
+    toString(): string;
+}
+//# sourceMappingURL=group.d.ts.map

package/dist/netcdf4-wasm/dist/group.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"group.d.ts","sourceRoot":"","sources":["../src/group.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAEzC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD,qBAAa,KAAK;IAOV,SAAS,CAAC,MAAM,EAAE,OAAO;aACT,IAAI,EAAE,MAAM;IAC5B,SAAS,CAAC,OAAO,EAAE,MAAM;IACzB,SAAS,CAAC,MAAM,CAAC,EAAE,KAAK;IAT5B,SAAgB,UAAU,EAAE;QAAE,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAA;KAAE,CAAM;IAC/D,SAAgB,SAAS,EAAE;QAAE,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,CAAA;KAAE,CAAM;IAC7D,SAAgB,MAAM,EAAE;QAAE,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK,CAAA;KAAE,CAAM;IACvD,OAAO,CAAC,WAAW,CAA8B;gBAGnC,MAAM,EAAE,OAAO,EACT,IAAI,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,KAAK,YAAA;IAI5B,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,GAAG,IAAI;IAcvC,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG;IAgB1B,KAAK,IAAI,MAAM,EAAE;IAIX,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAAC,SAAS,CAAC;IAoBrE,kBAAkB,IAAI,IAAI;IA8B3B,cAAc,CAChB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,UAAU,GAAE,MAAM,EAAO,EACzB,OAAO,GAAE,eAAoB,GAC9B,OAAO,CAAC,QAAQ,CAAC;IAqCpB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK;IAQhC,QAAQ,IAAI;QAAE,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK,CAAA;KAAE;IAKrC,IAAI,IAAI,IAAI,MAAM,CAIjB;IAEK,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAmD3B,QAAQ,IAAI,MAAM;CAGrB"}

package/dist/netcdf4-wasm/dist/group.js

@@ -0,0 +1,189 @@
+// Group class for hierarchical data organization
+import { Dimension } from './dimension.js';
+import { Variable } from './variable.js';
+import { NC_CONSTANTS, DATA_TYPE_MAP } from './constants.js';
+export class Group {
+    netcdf;
+    name;
+    groupId;
+    parent;
+    dimensions = {};
+    variables = {};
+    groups = {};
+    _attributes = {};
+    constructor(netcdf, name, groupId, parent) {
+        this.netcdf = netcdf;
+        this.name = name;
+        this.groupId = groupId;
+        this.parent = parent;
+    }
+    // Attribute methods
+    setAttr(name, value) {
+        this._attributes[name] = value;
+        // Store in mock file system if in test mode
+        if (typeof process !== 'undefined' && process.env.NODE_ENV === 'test') {
+            const mockFiles = global.__netcdf4_mock_files;
+            const dataset = this.netcdf;
+            if (mockFiles && dataset.filename && mockFiles[dataset.filename]) {
+                mockFiles[dataset.filename].attributes[name] = value;
+            }
+        }
+        // TODO: Implement actual NetCDF global attribute setting
+    }
+    getAttr(name) {
+        // Check mock file system first if in test mode
+        if (typeof process !== 'undefined' && process.env.NODE_ENV === 'test') {
+            const mockFiles = global.__netcdf4_mock_files;
+            const dataset = this.netcdf;
+            if (mockFiles && dataset.filename && mockFiles[dataset.filename]) {
+                const value = mockFiles[dataset.filename].attributes[name];
+                if (value !== undefined) {
+                    this._attributes[name] = value; // Sync local cache
+                    return value;
+                }
+            }
+        }
+        return this._attributes[name];
+    }
+    attrs() {
+        return Object.keys(this._attributes);
+    }
+    async createDimension(name, size) {
+        // Check for duplicate dimension name
+        if (this.dimensions[name]) {
+            throw new Error(`Dimension '${name}' already exists`);
+        }
+        // Check for invalid size values
+        if (size !== null && size < 0) {
+            throw new Error(`Invalid dimension size: ${size}. Size must be non-negative or null for unlimited.`);
+        }
+        // Handle unlimited dimension (null only — size=0 is a valid finite dimension)
+        const isUnlimited = size === null;
+        const ncSize = isUnlimited ? 0 : size; // Use 0 for unlimited in the actual NetCDF API
+        const dimid = await this.netcdf.defineDimension(this.groupId, name, ncSize);
+        const actualSize = isUnlimited ? NC_CONSTANTS.NC_UNLIMITED : size;
+        const dimension = new Dimension(name, actualSize, isUnlimited);
+        this.dimensions[name] = dimension;
+        return dimension;
+    }
+    // Load dimensions and variables from mock storage when in test mode
+    loadMockDimensions() {
+        if (typeof process !== 'undefined' && process.env.NODE_ENV === 'test') {
+            const mockFiles = global.__netcdf4_mock_files;
+            const dataset = this.netcdf;
+            if (mockFiles && dataset.filename && mockFiles[dataset.filename]) {
+                // Load dimensions
+                const mockDims = mockFiles[dataset.filename].dimensions;
+                for (const [name, dimData] of Object.entries(mockDims)) {
+                    const dimension = new Dimension(name, dimData.size, dimData.unlimited);
+                    this.dimensions[name] = dimension;
+                }
+                // Load variables
+                const mockVars = mockFiles[dataset.filename].variables;
+                for (const [name, varData] of Object.entries(mockVars)) {
+                    const varInfo = varData;
+                    // Reconstruct variable - for now, assume double datatype and no dimensions for simplicity
+                    const variable = new Variable(this.netcdf, name, varInfo.datatype || 'f8', varInfo.dimensions || [], 1, this.groupId);
+                    // Restore variable attributes
+                    if (varInfo.attributes) {
+                        for (const [attrName, attrValue] of Object.entries(varInfo.attributes)) {
+                            variable.setAttr(attrName, attrValue);
+                        }
+                    }
+                    this.variables[name] = variable;
+                }
+            }
+        }
+    }
+    async createVariable(name, datatype, dimensions = [], options = {}) {
+        const ncType = DATA_TYPE_MAP[datatype];
+        if (ncType === undefined) {
+            throw new Error(`Unsupported datatype: ${datatype}`);
+        }
+        // Get dimension IDs
+        const dimIds = dimensions.map(dimName => {
+            const dim = this.dimensions[dimName];
+            if (!dim) {
+                throw new Error(`Dimension '${dimName}' not found`);
+            }
+            // For now, we'll use the dimension name as ID (simplified)
+            return Object.keys(this.dimensions).indexOf(dimName);
+        });
+        const varid = await this.netcdf.defineVariable(this.groupId, name, ncType, dimIds);
+        const variable = new Variable(this.netcdf, name, datatype, dimensions, varid, this.groupId);
+        this.variables[name] = variable;
+        // Store variable metadata in mock storage if in test mode
+        if (typeof process !== 'undefined' && process.env.NODE_ENV === 'test') {
+            const mockFiles = global.__netcdf4_mock_files;
+            const dataset = this.netcdf;
+            if (mockFiles && dataset.filename && mockFiles[dataset.filename]) {
+                mockFiles[dataset.filename].variables[name] = {
+                    datatype: datatype,
+                    dimensions: dimensions,
+                    data: new Float64Array(0),
+                    attributes: {}
+                };
+            }
+        }
+        return variable;
+    }
+    createGroup(name) {
+        // For simplicity, groups use the same ncid for now
+        const group = new Group(this.netcdf, name, this.groupId, this);
+        this.groups[name] = group;
+        return group;
+    }
+    // Python-like method to get all children
+    children() {
+        return this.groups;
+    }
+    // Get group path (Python-like)
+    get path() {
+        if (!this.parent)
+            return '/';
+        const parentPath = this.parent.path;
+        return parentPath === '/' ? `/${this.name}` : `${parentPath}/${this.name}`;
+    }
+    async load() {
+        // 1. Dimensions
+        const dims = await this.netcdf.getDims(this.path);
+        for (const key in this.dimensions)
+            delete this.dimensions[key];
+        for (const [name, d] of Object.entries(dims)) {
+            this.dimensions[name] = new Dimension(name, d.size, false);
+        }
+        // 2. Variables
+        const vars = await this.netcdf.getGroupVariables(this.path);
+        for (const key in this.variables)
+            delete this.variables[key];
+        for (const [name, v] of Object.entries(vars)) {
+            const info = await this.netcdf.getVariableInfo(v.id, this.path);
+            const dimNames = info.dims.map((d) => d.name);
+            const variable = new Variable(this.netcdf, name, info.dtype, dimNames, v.id, this.groupId);
+            if (info.attributes) {
+                for (const [k, val] of Object.entries(info.attributes)) {
+                    variable.setAttr(k, val);
+                }
+            }
+            this.variables[name] = variable;
+        }
+        // 3. Subgroups
+        const groups = await this.netcdf.getGroups(this.groupId);
+        for (const key in this.groups)
+            delete this.groups[key];
+        for (const [name, grpid] of Object.entries(groups)) {
+            const group = new Group(this.netcdf, name, grpid, this);
+            await group.load();
+            this.groups[name] = group;
+        }
+        // 4. Attributes
+        const attrs = await this.netcdf.getGlobalAttributes(this.path);
+        for (const [k, v] of Object.entries(attrs)) {
+            this.setAttr(k, v);
+        }
+    }
+    toString() {
+        return `<netCDF4.Group '${this.path}'>`;
+    }
+}
+//# sourceMappingURL=group.js.map