Type-check attribute objects and values

axelboc · axelboc · commit 87251d640148 · 2026-01-28T14:21:10.000+01:00
diff --git a/packages/app/src/explorer/utils.ts b/packages/app/src/explorer/utils.ts
@@ -1,14 +1,15 @@
 import {
   assertDefined,
   assertNonNull,
-  assertStr,
+  hasScalarShape,
+  hasStringType,
   isGroup,
 } from '@h5web/shared/guards';
 import { type ChildEntity } from '@h5web/shared/hdf5-models';
 import { type KeyboardEvent } from 'react';
 
 import { type AttrValuesStore } from '../providers/models';
-import { hasAttribute } from '../utils';
+import { findAttribute, getAttributeValue, hasAttribute } from '../utils';
 
 const SUPPORTED_NX_CLASSES = new Set(['NXdata', 'NXentry', 'NXprocess']);
 
@@ -26,13 +27,17 @@ export function needsNxBadge(
     return true;
   }
 
-  const nxClass = attrValuesStore.getSingle(entity, 'NX_class');
-  if (nxClass) {
-    assertStr(nxClass);
-    return SUPPORTED_NX_CLASSES.has(nxClass);
+  const nxClassAttr = findAttribute(entity, 'NX_class');
+  if (
+    !nxClassAttr ||
+    !hasScalarShape(nxClassAttr) ||
+    !hasStringType(nxClassAttr)
+  ) {
+    return false;
   }
 
-  return false;
+  const nxClass = getAttributeValue(entity, nxClassAttr, attrValuesStore);
+  return SUPPORTED_NX_CLASSES.has(nxClass);
 }
 
 function getButtonList(
diff --git a/packages/app/src/hooks.ts b/packages/app/src/hooks.ts
@@ -1,5 +1,5 @@
 import { type DimensionMapping, getSliceSelection } from '@h5web/lib';
-import { assertDatasetValue, isDefined } from '@h5web/shared/guards';
+import { assertValue, isDefined } from '@h5web/shared/guards';
 import {
   type ArrayShape,
   type Dataset,
@@ -48,7 +48,7 @@ export function useDatasetValue<D extends Dataset<ArrayShape | ScalarShape>>(
   // If `selection` is undefined, the entire dataset will be fetched
   const value = valuesStore.get({ dataset, selection });
 
-  assertDatasetValue(value, dataset);
+  assertValue(value, dataset);
   return value;
 }
 
@@ -74,7 +74,7 @@ export function useDatasetsValues<D extends Dataset<ArrayShape | ScalarShape>>(
     }
 
     const value = valuesStore.get({ dataset, selection });
-    assertDatasetValue(value, dataset);
+    assertValue(value, dataset);
     return value;
   });
 }
diff --git a/packages/app/src/index.ts b/packages/app/src/index.ts
@@ -167,7 +167,7 @@ export {
   assertPrintableType,
   assertCompoundType,
   assertScalarValue,
-  assertDatasetValue,
+  assertValue as assertDatasetValue,
 } from '@h5web/shared/guards';
 
 // Undocumented
diff --git a/packages/app/src/utils.ts b/packages/app/src/utils.ts
@@ -1,11 +1,33 @@
-import { type Entity } from '@h5web/shared/hdf5-models';
+import { assertValue } from '@h5web/shared/guards';
+import {
+  type Attribute,
+  type Entity,
+  type Value,
+} from '@h5web/shared/hdf5-models';
 
-import { type AttrName } from './providers/models';
+import { type AttrName, type AttrValuesStore } from './providers/models';
 
 export function hasAttribute(entity: Entity, attributeName: AttrName): boolean {
   return entity.attributes.some((attr) => attr.name === attributeName);
 }
 
+export function findAttribute(
+  entity: Entity,
+  attributeName: AttrName,
+): Attribute | undefined {
+  return entity.attributes.find((attr) => attr.name === attributeName);
+}
+
+export function getAttributeValue<A extends Attribute>(
+  entity: Entity,
+  attribute: A,
+  attrValuesStore: AttrValuesStore,
+): Value<A> {
+  const value = attrValuesStore.get(entity)[attribute.name];
+  assertValue(value, attribute);
+  return value;
+}
+
 export function enableBigIntSerialization(): void {
   // eslint-disable-next-line no-extend-native
   Object.defineProperty(BigInt.prototype, 'toJSON', {
diff --git a/packages/app/src/vis-packs/core/hooks.ts b/packages/app/src/vis-packs/core/hooks.ts
@@ -1,6 +1,11 @@
 import { type DimensionMapping } from '@h5web/lib';
 import { createMemo } from '@h5web/shared/createMemo';
-import { isDefined } from '@h5web/shared/guards';
+import {
+  hasNumericType,
+  hasScalarShape,
+  isDefined,
+  isScalarShape,
+} from '@h5web/shared/guards';
 import {
   type ArrayValue,
   type Dataset,
@@ -22,6 +27,7 @@ import {
   bigIntTypedArrayFromDType,
   typedArrayFromDType,
 } from '../../providers/utils';
+import { findAttribute, getAttributeValue } from '../../utils';
 import { applyMapping, getBaseArray, toNumArray } from './utils';
 
 export const useToNumArray = createMemo(toNumArray);
@@ -99,27 +105,38 @@ export function useMappedArrays(
 export function useIgnoreFillValue(dataset: Dataset): IgnoreValue | undefined {
   const { attrValuesStore } = useDataContext();
 
-  const rawFillValue = attrValuesStore.getSingle(dataset, '_FillValue');
-
   return useMemo(() => {
-    const wrappedFillValue = castArray(rawFillValue);
+    const fillValueAttr = findAttribute(dataset, '_FillValue');
+
+    if (
+      !fillValueAttr ||
+      !hasScalarShape(fillValueAttr) ||
+      !hasNumericType(fillValueAttr)
+    ) {
+      return undefined;
+    }
+
+    const rawFillValue = getAttributeValue(
+      dataset,
+      fillValueAttr,
+      attrValuesStore,
+    );
 
     const DTypedArray = bigIntTypedArrayFromDType(dataset.type)
       ? Float64Array // matches `useToNumArray` logic
       : typedArrayFromDType(dataset.type);
 
     // Cast fillValue in the type of the dataset values to be able to use `===` for the comparison
-    const fillValue =
-      DTypedArray && typeof wrappedFillValue[0] === 'number'
-        ? new DTypedArray(wrappedFillValue as number[])[0]
-        : undefined;
+    const fillValue = DTypedArray
+      ? new DTypedArray([Number(rawFillValue)])[0]
+      : undefined;
 
     if (fillValue === undefined) {
       return undefined;
     }
 
     return (val) => val === fillValue;
-  }, [dataset, rawFillValue]);
+  }, [dataset, attrValuesStore]);
 }
 
 export function useExportEntries<F extends ExportFormat[]>(
diff --git a/packages/app/src/vis-packs/nexus/containers/NxHeatmapContainer.tsx b/packages/app/src/vis-packs/nexus/containers/NxHeatmapContainer.tsx
@@ -1,6 +1,6 @@
 import { DimensionMapper, getSliceSelection } from '@h5web/lib';
 import {
-  assertDatasetValue,
+  assertValue,
   assertGroup,
   assertMinDims,
   assertNumericLikeType,
@@ -81,7 +81,7 @@ function NxHeatmapContainer(props: VisContainerProps) {
             const { signal, axisValues, title } = nxValues;
 
             if (hasComplexType(selectedDataset)) {
-              assertDatasetValue(signal, selectedDataset);
+              assertValue(signal, selectedDataset);
 
               return (
                 <MappedComplexHeatmapVis
@@ -98,7 +98,7 @@ function NxHeatmapContainer(props: VisContainerProps) {
             }
 
             assertNumericLikeType(selectedDataset);
-            assertDatasetValue(signal, selectedDataset);
+            assertValue(signal, selectedDataset);
             return (
               <MappedHeatmapVis
                 dataset={selectedDataset}
diff --git a/packages/shared/src/guards.test.ts b/packages/shared/src/guards.test.ts
@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest';
 
-import { assertDatasetValue, assertScalarValue } from './guards';
+import { assertValue, assertScalarValue } from './guards';
 import {
   boolType,
   compoundType,
@@ -111,40 +111,34 @@ describe('assertScalarValue', () => {
 describe('assertDatasetValue', () => {
   it('should not throw when value satisfies dataset type and shape', () => {
     expect(() =>
-      assertDatasetValue(0, dataset('foo', intType(), [])),
+      assertValue(0, dataset('foo', intType(), [])),
     ).not.toThrowError();
 
     expect(() =>
-      assertDatasetValue(0n, dataset('foo', intType(false, 64), [])),
+      assertValue(0n, dataset('foo', intType(false, 64), [])),
     ).not.toThrowError();
 
     expect(() =>
-      assertDatasetValue('', dataset('foo', strType(), [])),
+      assertValue('', dataset('foo', strType(), [])),
     ).not.toThrowError();
 
     expect(() =>
-      assertDatasetValue(
-        [true, false],
-        dataset('foo', boolType(intType()), [2]),
-      ),
+      assertValue([true, false], dataset('foo', boolType(intType()), [2])),
     ).not.toThrowError();
 
     expect(() =>
-      assertDatasetValue(
-        Float32Array.from([0, 1]),
-        dataset('foo', floatType(), [2]),
-      ),
+      assertValue(Float32Array.from([0, 1]), dataset('foo', floatType(), [2])),
     ).not.toThrowError();
 
     expect(() =>
-      assertDatasetValue(
+      assertValue(
         BigInt64Array.from([0n, 1n]),
         dataset('foo', intType(true, 64), [2]),
       ),
     ).not.toThrowError();
 
     expect(() =>
-      assertDatasetValue(
+      assertValue(
         Float32Array.from([0, 1]), // big ints can be returned as any kind of numbers
         dataset('foo', intType(true, 64), [2]),
       ),
@@ -154,18 +148,15 @@ describe('assertDatasetValue', () => {
   describe('assertDatasetValue', () => {
     it("should throw when value doesn't satisfy dataset type and shape", () => {
       expect(() =>
-        assertDatasetValue(
-          true,
-          dataset('foo', enumType(intType(), { FOO: 0 }), []),
-        ),
+        assertValue(true, dataset('foo', enumType(intType(), { FOO: 0 }), [])),
       ).toThrowError('Expected number');
 
       expect(() =>
-        assertDatasetValue(['foo', 'bar'], dataset('foo', intType(), [2])),
+        assertValue(['foo', 'bar'], dataset('foo', intType(), [2])),
       ).toThrowError('Expected number');
 
       expect(() =>
-        assertDatasetValue(
+        assertValue(
           BigInt64Array.from([0n, 1n]),
           dataset('foo', intType(), [2]),
         ),
diff --git a/packages/shared/src/guards.ts b/packages/shared/src/guards.ts
diff --git a/packages/shared/src/hdf5-models.ts b/packages/shared/src/hdf5-models.ts
