@earthyscience/netcdf4-wasm 0.1.2 → 0.2.0

package/dist/netcdf4.js

@@ -151,6 +151,9 @@ export class NetCDF4 extends Group {
             if (typeof process !== 'undefined' && process.env.NODE_ENV === 'test') {
                 this.loadMockDimensions();
             }
+            else {
+                await this.load();
+            }
         }
         this._isOpen = true;
     }
@@ -263,22 +266,22 @@ export class NetCDF4 extends Group {
             });
         });
     }
-    async getGlobalAttributes() {
+    async getGlobalAttributes(groupPath) {
         if (this.worker) {
-            return this.callWorker('getGlobalAttributes');
+            return this.callWorker('getGlobalAttributes', { groupPath });
         }
         else {
             // Main thread path is already synchronous (or could be wrapped in Promise.resolve)
-            return NCGet.getGlobalAttributes(this.module, this.ncid);
+            return NCGet.getGlobalAttributes(this.module, this.ncid, groupPath);
         }
     }
-    async getFullMetadata() {
+    async getFullMetadata(groupPath) {
         if (this.worker) {
-            return this.callWorker('getFullMetadata');
+            return this.callWorker('getFullMetadata', { groupPath });
         }
         else {
             // Main thread path is already synchronous (or could be wrapped in Promise.resolve)
-            return NCGet.getFullMetadata(this.module, this.ncid);
+            return NCGet.getFullMetadata(this.module, this.ncid, groupPath);
         }
     }
     async getAttributeValues(varid, attname) {
@@ -290,67 +293,67 @@ export class NetCDF4 extends Group {
             return NCGet.getAttributeValues(this.module, this.ncid, varid, attname);
         }
     }
-    async getDimCount() {
+    async getDimCount(ncid = this.ncid) {
         if (this.worker) {
-            return this.callWorker('getDimCount');
+            return this.callWorker('getDimCount', { ncid });
         }
         else {
             // Main thread path is already synchronous (or could be wrapped in Promise.resolve)
-            return NCGet.getDimCount(this.module, this.ncid);
+            return NCGet.getDimCount(this.module, ncid);
         }
     }
-    async getVariables() {
+    async getGroupVariables(groupPath) {
         if (this.worker) {
-            return this.callWorker('getVariables');
+            return this.callWorker('getGroupVariables', { groupPath });
         }
         else {
             // Main thread path is already synchronous (or could be wrapped in Promise.resolve)
-            return NCGet.getVariables(this.module, this.ncid);
+            return NCGet.getGroupVariables(this.module, this.ncid, groupPath);
         }
     }
-    async getVarIDs() {
+    async getVarIDs(ncid = this.ncid) {
         if (this.worker) {
-            return this.callWorker('getVarIDs');
+            return this.callWorker('getVarIDs', { ncid });
         }
         else {
             // Main thread path is already synchronous (or could be wrapped in Promise.resolve)
-            return NCGet.getVarIDs(this.module, this.ncid);
+            return NCGet.getVarIDs(this.module, ncid);
         }
     }
-    async getDimIDs() {
+    async getDimIDs(ncid = this.ncid) {
         if (this.worker) {
-            return this.callWorker('getDimIDs');
+            return this.callWorker('getDimIDs', { ncid });
         }
         else {
             // Main thread path is already synchronous (or could be wrapped in Promise.resolve)
-            return NCGet.getDimIDs(this.module, this.ncid);
+            return NCGet.getDimIDs(this.module, ncid);
         }
     }
-    async getDim(dimid) {
+    async getDim(dimid, ncid = this.ncid) {
         if (this.worker) {
-            return this.callWorker('getDim', { dimid });
+            return this.callWorker('getDim', { dimid, ncid });
         }
         else {
             // Main thread path is already synchronous (or could be wrapped in Promise.resolve)
-            return NCGet.getDim(this.module, this.ncid, dimid);
+            return NCGet.getDim(this.module, ncid, dimid);
         }
     }
-    async getDims() {
+    async getDims(groupPath) {
         if (this.worker) {
-            return this.callWorker('getDims');
+            return this.callWorker('getDims', { groupPath });
         }
         else {
             // Main thread path is already synchronous (or could be wrapped in Promise.resolve)
-            return NCGet.getDims(this.module, this.ncid);
+            return NCGet.getDims(this.module, this.ncid, groupPath);
         }
     }
-    async getVarCount() {
+    async getVarCount(ncid = this.ncid) {
         if (this.worker) {
-            return this.callWorker('getVarCount');
+            return this.callWorker('getVarCount', { ncid });
         }
         else {
             // Main thread path is already synchronous (or could be wrapped in Promise.resolve)
-            return NCGet.getVarCount(this.module, this.ncid);
+            return NCGet.getVarCount(this.module, ncid);
         }
     }
     async getAttributeName(varid, attId) {
@@ -362,31 +365,72 @@ export class NetCDF4 extends Group {
             return NCGet.getAttributeName(this.module, this.ncid, varid, attId);
         }
     }
-    async getVariableInfo(variable) {
+    async getVariableInfo(variable, groupPath) {
         if (this.worker) {
-            return this.callWorker('getVariableInfo', { variable });
+            return this.callWorker('getVariableInfo', { variable, groupPath });
         }
         else {
             // Main thread path is already synchronous (or could be wrapped in Promise.resolve)
-            return NCGet.getVariableInfo(this.module, this.ncid, variable);
+            return NCGet.getVariableInfo(this.module, this.ncid, variable, groupPath);
         }
     }
-    async getVariableArray(variable) {
+    async getVariableArray(variable, groupPath) {
         if (this.worker) {
-            return this.callWorker('getVariableArray', { variable });
+            return this.callWorker('getVariableArray', { variable, groupPath });
         }
         else {
             // Main thread path is already synchronous (or could be wrapped in Promise.resolve)
-            return NCGet.getVariableArray(this.module, this.ncid, variable);
+            return NCGet.getVariableArray(this.module, this.ncid, variable, groupPath);
         }
     }
-    async getSlicedVariableArray(variable, start, count) {
+    async getSlicedVariableArray(variable, start, count, groupPath) {
         if (this.worker) {
-            return this.callWorker('getSlicedVariableArray', { variable, start, count });
+            return this.callWorker('getSlicedVariableArray', { variable, start, count, groupPath });
         }
         else {
             // Main thread path is already synchronous (or could be wrapped in Promise.resolve)
-            return NCGet.getSlicedVariableArray(this.module, this.ncid, variable, start, count);
+            return NCGet.getSlicedVariableArray(this.module, this.ncid, variable, start, count, groupPath);
+        }
+    }
+    // Group functions
+    async getGroups(ncid = this.ncid) {
+        if (this.worker) {
+            return this.callWorker('getGroups', { ncid });
+        }
+        else {
+            return NCGet.getGroups(this.module, ncid);
+        }
+    }
+    async getGroupsRecursive(ncid = this.ncid) {
+        if (this.worker) {
+            return this.callWorker('getGroupsRecursive', { ncid });
+        }
+        else {
+            return NCGet.getGroupsRecursive(this.module, ncid);
+        }
+    }
+    async getGroupNCID(groupPath) {
+        if (this.worker) {
+            return this.callWorker('getGroupNCID', { groupPath });
+        }
+        else {
+            return NCGet.getGroupNCID(this.module, this.ncid, groupPath);
+        }
+    }
+    async getGroupName(ncid = this.ncid) {
+        if (this.worker) {
+            return this.callWorker('getGroupName', { ncid });
+        }
+        else {
+            return NCGet.getGroupName(this.module, ncid);
+        }
+    }
+    async getGroupPath(ncid = this.ncid) {
+        if (this.worker) {
+            return this.callWorker('getGroupPath', { ncid });
+        }
+        else {
+            return NCGet.getGroupPath(this.module, ncid);
         }
     }
     async defineDimension(ncid, name, size) {
@@ -633,5 +677,347 @@ export class NetCDF4 extends Group {
         const source = this.memorySource ? '(in-memory)' : '';
         return `<netCDF4.Dataset '${this.filename}'${source}: mode = '${this.mode}', file format = '${this.file_format}', ${status}>`;
     }
+    /**
+ * Get complete hierarchy of groups, variables, dimensions, and attributes
+ * This is the unified method for exploring the entire file structure
+ * @param groupPath - Optional path to start from a specific group
+ */
+    async getCompleteHierarchy(groupPath) {
+        if (this.worker) {
+            return this.callWorker('getCompleteHierarchy', { groupPath });
+        }
+        else {
+            return NCGet.getCompleteHierarchy(this.module, this.ncid, groupPath);
+        }
+    }
+    /**
+     * Get all variables recursively from all groups
+     * Returns a flat dictionary with full path keys like "/group1/var1"
+     */
+    async getVariables() {
+        if (this.worker) {
+            return this.callWorker('getVariables');
+        }
+        else {
+            return NCGet.getVariables(this.module, this.ncid);
+        }
+    }
+}
+/**
+ * UI-friendly wrapper around NetCDF4
+ * Builds a full dataTree of groups, variables, attributes with enhanced navigation
+ */
+export class DataTree {
+    dataset;
+    tree = {};
+    groupTreeCache = null;
+    constructor(dataset) {
+        this.dataset = dataset;
+    }
+    async buildTree() {
+        this.tree = await this.dataset.getCompleteHierarchy();
+        // Clear cache when tree is rebuilt
+        this.groupTreeCache = null;
+    }
+    // --------------------------------------------------
+    // Core navigation
+    // --------------------------------------------------
+    getGroup(groupPath = '/') {
+        if (!this.tree)
+            return null;
+        if (groupPath === '/' || !groupPath)
+            return this.tree;
+        const parts = groupPath.split('/').filter(Boolean);
+        let current = this.tree;
+        for (const part of parts) {
+            if (!current.groups || !current.groups[part])
+                return null;
+            current = current.groups[part];
+        }
+        return current;
+    }
+    getGroupName(groupPath) {
+        if (!groupPath || groupPath === '/')
+            return 'root';
+        const parts = groupPath.split('/').filter(Boolean);
+        return parts[parts.length - 1];
+    }
+    hasSubgroups(groupPath = '/') {
+        const group = this.getGroup(groupPath);
+        return group ? Object.keys(group.groups || {}).length > 0 : false;
+    }
+    // --------------------------------------------------
+    // Groups (for dropdowns)
+    // --------------------------------------------------
+    /** immediate children only */
+    listGroups(groupPath = '/') {
+        const group = this.getGroup(groupPath);
+        if (!group || !group.groups)
+            return [];
+        return Object.entries(group.groups).map(([name, g]) => ({
+            name,
+            path: g.path || `${groupPath === '/' ? '' : groupPath}/${name}`
+        }));
+    }
+    /** every group recursively */
+    listAllGroups() {
+        const result = [];
+        const walk = (g) => {
+            if (!g.groups)
+                return;
+            for (const [name, sub] of Object.entries(g.groups)) {
+                result.push({ name, path: sub.path });
+                walk(sub);
+            }
+        };
+        walk(this.tree);
+        return result;
+    }
+    // --------------------------------------------------
+    // Hierarchical Group Tree
+    // --------------------------------------------------
+    /**
+     * Build a hierarchical tree structure of all groups
+     * Returns a tree with parent-child relationships
+     * Results are cached until buildTree() is called again
+     */
+    buildGroupTree() {
+        // Return cached version if available
+        if (this.groupTreeCache) {
+            return this.groupTreeCache;
+        }
+        const allGroups = this.listAllGroups();
+        // Create root node
+        const root = {
+            name: '/',
+            path: '/',
+            children: [],
+            hasVariables: this.hasVariables('/'),
+            hasAttributes: this.hasAttributes('/'),
+            variableCount: this.getVariableCount('/'),
+            attributeCount: this.getAttributeCount('/')
+        };
+        // Map to store all nodes by path for quick lookup
+        const nodeMap = new Map();
+        nodeMap.set('/', root);
+        // Sort groups by path depth to ensure parents are created before children
+        const sortedGroups = allGroups.sort((a, b) => {
+            const depthA = a.path.split('/').filter(Boolean).length;
+            const depthB = b.path.split('/').filter(Boolean).length;
+            return depthA - depthB;
+        });
+        // Build the tree
+        for (const { name, path } of sortedGroups) {
+            const node = {
+                name,
+                path,
+                children: [],
+                hasVariables: this.hasVariables(path),
+                hasAttributes: this.hasAttributes(path),
+                variableCount: this.getVariableCount(path),
+                attributeCount: this.getAttributeCount(path)
+            };
+            nodeMap.set(path, node);
+            // Find parent path
+            const pathParts = path.split('/').filter(Boolean);
+            const parentPath = pathParts.length === 1
+                ? '/'
+                : '/' + pathParts.slice(0, -1).join('/');
+            const parent = nodeMap.get(parentPath);
+            if (parent) {
+                parent.children.push(node);
+            }
+        }
+        // Cache the result
+        this.groupTreeCache = root;
+        return root;
+    }
+    /**
+     * Get a specific node from the group tree by path
+     */
+    getGroupNode(path) {
+        const tree = this.buildGroupTree();
+        if (path === '/')
+            return tree;
+        const parts = path.split('/').filter(Boolean);
+        let current = tree;
+        for (const part of parts) {
+            const child = current.children.find(c => c.name === part);
+            if (!child)
+                return null;
+            current = child;
+        }
+        return current;
+    }
+    /**
+     * Get breadcrumb trail for a given path
+     * Returns array of {name, path} from root to target
+     */
+    getBreadcrumbs(groupPath) {
+        if (groupPath === '/') {
+            return [{ name: 'root', path: '/' }];
+        }
+        const parts = groupPath.split('/').filter(Boolean);
+        const breadcrumbs = [
+            { name: 'root', path: '/' }
+        ];
+        let currentPath = '';
+        for (const part of parts) {
+            currentPath += '/' + part;
+            breadcrumbs.push({
+                name: part,
+                path: currentPath
+            });
+        }
+        return breadcrumbs;
+    }
+    /**
+     * Search for groups by name (case-insensitive)
+     */
+    searchGroups(query) {
+        const lowerQuery = query.toLowerCase();
+        return this.listAllGroups().filter(g => g.name.toLowerCase().includes(lowerQuery) ||
+            g.path.toLowerCase().includes(lowerQuery));
+    }
+    // --------------------------------------------------
+    // Variables
+    // --------------------------------------------------
+    /** variables inside a group */
+    getAllVariables(groupPath = '/') {
+        const group = this.getGroup(groupPath);
+        return group?.variables || {};
+    }
+    /** check if group has variables */
+    hasVariables(groupPath = '/') {
+        const vars = this.getAllVariables(groupPath);
+        return Object.keys(vars).length > 0;
+    }
+    /** count variables in a group */
+    getVariableCount(groupPath = '/') {
+        return Object.keys(this.getAllVariables(groupPath)).length;
+    }
+    /** get variable names as array */
+    getVariableNames(groupPath = '/') {
+        return Object.keys(this.getAllVariables(groupPath));
+    }
+    /**
+     * Search for variables by name across all groups
+     */
+    searchVariables(query) {
+        const results = [];
+        const lowerQuery = query.toLowerCase();
+        const searchInGroup = (groupPath) => {
+            const vars = this.getAllVariables(groupPath);
+            for (const varName of Object.keys(vars)) {
+                if (varName.toLowerCase().includes(lowerQuery)) {
+                    results.push({
+                        name: varName,
+                        groupPath,
+                        path: `${groupPath === '/' ? '' : groupPath}/${varName}`
+                    });
+                }
+            }
+            // Recurse into subgroups
+            const subgroups = this.listGroups(groupPath);
+            for (const { path } of subgroups) {
+                searchInGroup(path);
+            }
+        };
+        searchInGroup('/');
+        return results;
+    }
+    // --------------------------------------------------
+    // Attributes
+    // --------------------------------------------------
+    /** attributes from the tree (fast) */
+    getAttributes(groupPath = '/') {
+        const group = this.getGroup(groupPath);
+        return group?.attributes || {};
+    }
+    /** check if group has attributes */
+    hasAttributes(groupPath = '/') {
+        const attrs = this.getAttributes(groupPath);
+        return Object.keys(attrs).length > 0;
+    }
+    /** count attributes in a group */
+    getAttributeCount(groupPath = '/') {
+        return Object.keys(this.getAttributes(groupPath)).length;
+    }
+    // --------------------------------------------------
+    // Dimensions
+    // --------------------------------------------------
+    /** get dimensions for a group */
+    getDimensions(groupPath = '/') {
+        const group = this.getGroup(groupPath);
+        return group?.dimensions || {};
+    }
+    /** check if group has dimensions */
+    hasDimensions(groupPath = '/') {
+        const dims = this.getDimensions(groupPath);
+        return Object.keys(dims).length > 0;
+    }
+    /** count dimensions in a group */
+    getDimensionCount(groupPath = '/') {
+        return Object.keys(this.getDimensions(groupPath)).length;
+    }
+    // --------------------------------------------------
+    // Statistics and Summaries
+    // --------------------------------------------------
+    /**
+     * Get summary statistics for a group
+     */
+    getGroupSummary(groupPath = '/') {
+        const group = this.getGroup(groupPath);
+        if (!group)
+            return null;
+        return {
+            path: groupPath,
+            name: this.getGroupName(groupPath),
+            variableCount: this.getVariableCount(groupPath),
+            attributeCount: this.getAttributeCount(groupPath),
+            dimensionCount: this.getDimensionCount(groupPath),
+            subgroupCount: this.listGroups(groupPath).length,
+            hasSubgroups: this.hasSubgroups(groupPath)
+        };
+    }
+    /**
+     * Get complete statistics for the entire dataset
+     */
+    getDatasetSummary() {
+        let totalVariables = 0;
+        let totalAttributes = 0;
+        let totalDimensions = 0;
+        let maxDepth = 0;
+        const countInGroup = (groupPath, depth) => {
+            totalVariables += this.getVariableCount(groupPath);
+            totalAttributes += this.getAttributeCount(groupPath);
+            totalDimensions += this.getDimensionCount(groupPath);
+            maxDepth = Math.max(maxDepth, depth);
+            const subgroups = this.listGroups(groupPath);
+            for (const { path } of subgroups) {
+                countInGroup(path, depth + 1);
+            }
+        };
+        countInGroup('/', 0);
+        return {
+            totalGroups: this.listAllGroups().length + 1, // +1 for root
+            totalVariables,
+            totalAttributes,
+            totalDimensions,
+            maxDepth
+        };
+    }
+    // --------------------------------------------------
+    // Heavy operations → still go to dataset
+    // --------------------------------------------------
+    async getVariableArray(variable, groupPath) {
+        return this.dataset.getVariableArray(variable, groupPath);
+    }
+    async getSlicedVariableArray(variable, start, count, groupPath) {
+        return this.dataset.getSlicedVariableArray(variable, start, count, groupPath);
+    }
+    async getVariableInfo(variable, groupPath) {
+        return this.dataset.getVariableInfo(variable, groupPath);
+    }
 }
 //# sourceMappingURL=netcdf4.js.map