@vitessce/neuroglancer 3.9.5 → 3.9.6

package/src/shader-utils.test.js

@@ -0,0 +1,432 @@
+import { describe, it, expect, vi } from 'vitest';
+
+import {
+  getSpatialLayerColorShader,
+  getSpatialLayerColorWithSelectionShader,
+  getSpatialLayerColorFilteredShader,
+  getGeneSelectionNoSelectionShader,
+  getGeneSelectionWithSelectionShader,
+  getGeneSelectionFilteredShader,
+  getRandomByFeatureShader,
+  getRandomByFeatureWithSelectionShader,
+  getRandomByFeatureFilteredShader,
+  getRandomPerPointShader,
+  getRandomPerPointWithSelectionShader,
+  getRandomPerPointFilteredShader,
+} from './shader-utils.js';
+
+// Mock the @vitessce/utils module before importing the module under test.
+vi.mock('@vitessce/utils', () => ({
+  PALETTE: [
+    [255, 0, 0],
+    [0, 255, 0],
+    [0, 0, 255],
+  ],
+  getDefaultColor: theme => (theme === 'dark' ? [128, 128, 128] : [200, 200, 200]),
+}));
+
+/**
+ * Helper: compare two shader strings line-by-line, ignoring
+ * leading/trailing whitespace on each line and ignoring empty lines.
+ */
+function expectShaderEqual(actual, expected) {
+  const normalize = s => s
+    .split('\n')
+    .map(line => line.trim())
+    .filter(line => line.length > 0);
+  expect(normalize(actual)).toEqual(normalize(expected));
+}
+
+// ============================================================
+// Case 1: spatialLayerColor
+// ============================================================
+
+describe('getSpatialLayerColorShader', () => {
+  it('generates a shader that sets all points to the static color', () => {
+    const result = getSpatialLayerColorShader([255, 128, 0], 0.8);
+    const expected = `
+void main() {
+    setColor(vec4(1, 0.5019607843137255, 0, 0.8));
+}
+`;
+    expectShaderEqual(result, expected);
+  });
+
+  it('handles zero opacity', () => {
+    const result = getSpatialLayerColorShader([0, 0, 0], 0);
+    const expected = `
+void main() {
+    setColor(vec4(0, 0, 0, 0));
+}
+`;
+    expectShaderEqual(result, expected);
+  });
+
+  it('handles full white at full opacity', () => {
+    const result = getSpatialLayerColorShader([255, 255, 255], 1.0);
+    const expected = `
+void main() {
+    setColor(vec4(1, 1, 1, 1));
+}
+`;
+    expectShaderEqual(result, expected);
+  });
+});
+
+describe('getSpatialLayerColorWithSelectionShader', () => {
+  it('generates a shader that colors selected features with static color and unselected with default', () => {
+    const result = getSpatialLayerColorWithSelectionShader(
+      [255, 0, 0], 0.5, [2, 5], [128, 128, 128], 'gene_index',
+    );
+    const expected = `
+void main() {
+    int geneIndex = prop_gene_index();
+    int selectedIndices[2] = int[2](2, 5);
+    bool isSelected = false;
+    for (int i = 0; i < 2; ++i) {
+        if (geneIndex == selectedIndices[i]) {
+            isSelected = true;
+        }
+    }
+    if (isSelected) {
+        setColor(vec4(1, 0, 0, 0.5));
+    } else {
+        setColor(vec4(0.5019607843137255, 0.5019607843137255, 0.5019607843137255, 0.5));
+    }
+}
+`;
+    expectShaderEqual(result, expected);
+  });
+
+  it('generates correct shader with a single selected feature', () => {
+    const result = getSpatialLayerColorWithSelectionShader(
+      [0, 255, 0], 1.0, [10], [0, 0, 0], 'feat_idx',
+    );
+    const expected = `
+void main() {
+    int geneIndex = prop_feat_idx();
+    int selectedIndices[1] = int[1](10);
+    bool isSelected = false;
+    for (int i = 0; i < 1; ++i) {
+        if (geneIndex == selectedIndices[i]) {
+            isSelected = true;
+        }
+    }
+    if (isSelected) {
+        setColor(vec4(0, 1, 0, 1));
+    } else {
+        setColor(vec4(0, 0, 0, 1));
+    }
+}
+`;
+    expectShaderEqual(result, expected);
+  });
+});
+
+describe('getSpatialLayerColorFilteredShader', () => {
+  it('generates a shader that discards unselected points', () => {
+    const result = getSpatialLayerColorFilteredShader(
+      [0, 0, 255], 0.9, [3, 7, 11], 'gene_index',
+    );
+    const expected = `
+void main() {
+    int geneIndex = prop_gene_index();
+    int selectedIndices[3] = int[3](3, 7, 11);
+    bool isSelected = false;
+    for (int i = 0; i < 3; ++i) {
+        if (geneIndex == selectedIndices[i]) {
+            isSelected = true;
+        }
+    }
+    if (!isSelected) {
+        discard;
+    }
+    setColor(vec4(0, 0, 1, 0.9));
+}
+`;
+    expectShaderEqual(result, expected);
+  });
+});
+
+// ============================================================
+// Case 2: geneSelection
+// ============================================================
+
+describe('getGeneSelectionNoSelectionShader', () => {
+  it('generates a shader identical to spatialLayerColor (static color for all)', () => {
+    const result = getGeneSelectionNoSelectionShader([100, 200, 50], 0.7);
+    const expected = `
+void main() {
+    setColor(vec4(0.39215686274509803, 0.7843137254901961, 0.19607843137254902, 0.7));
+}
+`;
+    expectShaderEqual(result, expected);
+  });
+});
+
+describe('getGeneSelectionWithSelectionShader', () => {
+  it('generates a shader with per-feature colors for selected and default for unselected', () => {
+    const result = getGeneSelectionWithSelectionShader(
+      [1, 4],
+      [[255, 0, 0], [0, 255, 0]],
+      [128, 128, 128],
+      [50, 50, 50],
+      0.6,
+      'gene_index',
+    );
+    const expected = `
+void main() {
+    int geneIndex = prop_gene_index();
+    int selectedIndices[2] = int[2](1, 4);
+    vec3 featureColors[2] = vec3[2](vec3(1, 0, 0), vec3(0, 1, 0));
+    vec4 color = vec4(0.19607843137254902, 0.19607843137254902, 0.19607843137254902, 0.6);
+    for (int i = 0; i < 2; ++i) {
+        if (geneIndex == selectedIndices[i]) {
+            color = vec4(featureColors[i], 0.6);
+        }
+    }
+    setColor(color);
+}
+`;
+    expectShaderEqual(result, expected);
+  });
+
+  it('uses static color as fallback when feature color is falsy', () => {
+    // The code uses `c ? toVec3(c) : toVec3(normStatic)`.
+    // normalizeColor always returns an array (truthy), so the fallback
+    // only triggers if the original color was falsy before normalization.
+    // Since featureColors are always normalized, we just check the normal path.
+    const result = getGeneSelectionWithSelectionShader(
+      [0],
+      [[0, 0, 255]],
+      [255, 255, 255],
+      [0, 0, 0],
+      1.0,
+      'fi',
+    );
+    const expected = `
+void main() {
+    int geneIndex = prop_fi();
+    int selectedIndices[1] = int[1](0);
+    vec3 featureColors[1] = vec3[1](vec3(0, 0, 1));
+    vec4 color = vec4(0, 0, 0, 1);
+    for (int i = 0; i < 1; ++i) {
+        if (geneIndex == selectedIndices[i]) {
+            color = vec4(featureColors[i], 1);
+        }
+    }
+    setColor(color);
+}
+`;
+    expectShaderEqual(result, expected);
+  });
+});
+
+describe('getGeneSelectionFilteredShader', () => {
+  it('generates a shader that discards unselected and colors selected per-feature', () => {
+    const result = getGeneSelectionFilteredShader(
+      [2, 8],
+      [[255, 0, 0], [0, 0, 255]],
+      [128, 128, 128],
+      0.75,
+      'gene_index',
+    );
+    const expected = `
+void main() {
+    int geneIndex = prop_gene_index();
+    int selectedIndices[2] = int[2](2, 8);
+    vec3 featureColors[2] = vec3[2](vec3(1, 0, 0), vec3(0, 0, 1));
+    bool isSelected = false;
+    vec3 matchedColor = vec3(0.0);
+    for (int i = 0; i < 2; ++i) {
+        if (geneIndex == selectedIndices[i]) {
+            isSelected = true;
+            matchedColor = featureColors[i];
+        }
+    }
+    if (!isSelected) {
+        discard;
+    }
+    setColor(vec4(matchedColor, 0.75));
+}
+`;
+    expectShaderEqual(result, expected);
+  });
+});
+
+// ============================================================
+// Case 3: randomByFeature
+// ============================================================
+
+describe('getRandomByFeatureShader', () => {
+  it('generates a shader using the palette to color by feature index', () => {
+    const result = getRandomByFeatureShader(0.5, 'gene_index');
+    const expected = `
+void main() {
+    int geneIndex = prop_gene_index();
+    vec3 palette[3] = vec3[3](vec3(1, 0, 0), vec3(0, 1, 0), vec3(0, 0, 1));
+    int colorIdx = geneIndex - (geneIndex / 3) * 3;
+    if (colorIdx < 0) { colorIdx = -colorIdx; }
+    vec3 color = palette[colorIdx];
+    setColor(vec4(color, 0.5));
+}
+`;
+    expectShaderEqual(result, expected);
+  });
+});
+
+describe('getRandomByFeatureWithSelectionShader', () => {
+  it('generates a shader with palette colors for selected and default for unselected', () => {
+    const result = getRandomByFeatureWithSelectionShader(
+      [1, 2], [50, 50, 50], 0.8, 'gene_index',
+    );
+    const expected = `
+void main() {
+    int geneIndex = prop_gene_index();
+    vec3 palette[3] = vec3[3](vec3(1, 0, 0), vec3(0, 1, 0), vec3(0, 0, 1));
+    int selectedIndices[2] = int[2](1, 2);
+    bool isSelected = false;
+    for (int i = 0; i < 2; ++i) {
+        if (geneIndex == selectedIndices[i]) {
+            isSelected = true;
+        }
+    }
+    if (isSelected) {
+        int colorIdx = geneIndex - (geneIndex / 3) * 3;
+        if (colorIdx < 0) { colorIdx = -colorIdx; }
+        setColor(vec4(palette[colorIdx], 0.8));
+    } else {
+        setColor(vec4(0.19607843137254902, 0.19607843137254902, 0.19607843137254902, 0.8));
+    }
+}
+`;
+    expectShaderEqual(result, expected);
+  });
+});
+
+describe('getRandomByFeatureFilteredShader', () => {
+  it('generates a shader that discards unselected and uses palette for selected', () => {
+    const result = getRandomByFeatureFilteredShader([0], 1.0, 'gene_index');
+    const expected = `
+void main() {
+    int geneIndex = prop_gene_index();
+    vec3 palette[3] = vec3[3](vec3(1, 0, 0), vec3(0, 1, 0), vec3(0, 0, 1));
+    int selectedIndices[1] = int[1](0);
+    bool isSelected = false;
+    for (int i = 0; i < 1; ++i) {
+        if (geneIndex == selectedIndices[i]) {
+            isSelected = true;
+        }
+    }
+    if (!isSelected) {
+        discard;
+    }
+    int colorIdx = geneIndex - (geneIndex / 3) * 3;
+    if (colorIdx < 0) { colorIdx = -colorIdx; }
+    setColor(vec4(palette[colorIdx], 1));
+}
+`;
+    expectShaderEqual(result, expected);
+  });
+});
+
+// ============================================================
+// Case 4: random (per point)
+// ============================================================
+
+describe('getRandomPerPointShader', () => {
+  it('generates a shader with pseudo-random color per point', () => {
+    const result = getRandomPerPointShader(0.9, 'gene_index', 'point_index');
+    const expected = `
+float hashToFloat(int v, int seed) {
+    int h = v ^ (seed * 16777619);
+    h = h * 747796405 + 2891336453;
+    h = ((h >> 16) ^ h) * 2654435769;
+    h = ((h >> 16) ^ h);
+    return float(h & 0x7FFFFFFF) / float(0x7FFFFFFF);
+}
+void main() {
+    int geneIndex = prop_gene_index();
+    int pointIndex = prop_point_index();
+    float r = hashToFloat(pointIndex, 0);
+    float g = hashToFloat(pointIndex, 1);
+    float b = hashToFloat(pointIndex, 2);
+    setColor(vec4(r, g, b, 0.9));
+}
+`;
+    expectShaderEqual(result, expected);
+  });
+});
+
+describe('getRandomPerPointWithSelectionShader', () => {
+  it('generates a shader with random colors for selected and default for unselected', () => {
+    const result = getRandomPerPointWithSelectionShader(
+      [3, 6], [100, 100, 100], 0.5, 'gene_index', 'point_index',
+    );
+    const expected = `
+float hashToFloat(int v, int seed) {
+    int h = v ^ (seed * 16777619);
+    h = h * 747796405 + 2891336453;
+    h = ((h >> 16) ^ h) * 2654435769;
+    h = ((h >> 16) ^ h);
+    return float(h & 0x7FFFFFFF) / float(0x7FFFFFFF);
+}
+void main() {
+    int geneIndex = prop_gene_index();
+    int pointIndex = prop_point_index();
+    int selectedIndices[2] = int[2](3, 6);
+    bool isSelected = false;
+    for (int i = 0; i < 2; ++i) {
+        if (geneIndex == selectedIndices[i]) {
+            isSelected = true;
+        }
+    }
+    if (isSelected) {
+        float r = hashToFloat(pointIndex, 0);
+        float g = hashToFloat(pointIndex, 1);
+        float b = hashToFloat(pointIndex, 2);
+        setColor(vec4(r, g, b, 0.5));
+    } else {
+        setColor(vec4(0.39215686274509803, 0.39215686274509803, 0.39215686274509803, 0.5));
+    }
+}
+`;
+    expectShaderEqual(result, expected);
+  });
+});
+
+describe('getRandomPerPointFilteredShader', () => {
+  it('generates a shader that discards unselected and uses random color for selected', () => {
+    const result = getRandomPerPointFilteredShader(
+      [5], 1.0, 'gene_index', 'point_index',
+    );
+    const expected = `
+float hashToFloat(int v, int seed) {
+    int h = v ^ (seed * 16777619);
+    h = h * 747796405 + 2891336453;
+    h = ((h >> 16) ^ h) * 2654435769;
+    h = ((h >> 16) ^ h);
+    return float(h & 0x7FFFFFFF) / float(0x7FFFFFFF);
+}
+void main() {
+    int geneIndex = prop_gene_index();
+    int pointIndex = prop_point_index();
+    int selectedIndices[1] = int[1](5);
+    bool isSelected = false;
+    for (int i = 0; i < 1; ++i) {
+        if (geneIndex == selectedIndices[i]) {
+            isSelected = true;
+        }
+    }
+    if (!isSelected) {
+        discard;
+    }
+    float r = hashToFloat(pointIndex, 0);
+    float g = hashToFloat(pointIndex, 1);
+    float b = hashToFloat(pointIndex, 2);
+    setColor(vec4(r, g, b, 1));
+}
+`;
+    expectShaderEqual(result, expected);
+  });
+});

package/src/use-memo-custom-comparison.js

@@ -0,0 +1,189 @@
+/* eslint-disable no-unused-vars */
+/* eslint-disable max-len */
+import { useRef } from 'react';
+
+/**
+ * A variant of useMemo that accepts a custom equality function
+ * to determine whether the dependencies have changed.
+ * @template T
+ * @param {() => T} factory - Function that computes the memoized value.
+ * @param {any} dependencies - The useMemo dependencies.
+ * @param {(prevDeps: any, nextDeps: any) => boolean} customIsEqual - Custom equality function,
+ * which receives the previous and next dependencies and returns true if they are considered equal.
+ * @returns {T} The memoized value.
+ */
+export function useMemoCustomComparison(factory, dependencies, customIsEqual) {
+  const ref = useRef(/** @type {{ deps: any; value: T } | undefined} */ (undefined));
+
+  if (ref.current === undefined || !customIsEqual(ref.current.deps, dependencies)) {
+    ref.current = { deps: dependencies, value: factory() };
+  }
+
+  return ref.current.value;
+}
+
+
+// Comparison utilties inspired by componentDidUpdate in spatial-beta/Spatial.js:
+const shallowDiff = (prevDeps, nextDeps, depName) => prevDeps[depName] !== nextDeps[depName];
+const shallowDiffByLayer = (prevDeps, nextDeps, depName, scopeName) => (
+  prevDeps?.[depName]?.[scopeName] !== nextDeps?.[depName]?.[scopeName]
+);
+// Rather than checking equality of the entire object,
+// here, we only shallowly compare the specific properties that are relevant.
+const shallowDiffByLayerWithKeys = (prevDeps, nextDeps, depName, scopeName, keys) => keys.some(
+  k => (prevDeps?.[depName]?.[scopeName]?.[k] !== nextDeps?.[depName]?.[scopeName]?.[k]),
+);
+const shallowDiffByChannel = (prevDeps, nextDeps, depName, firstName, secondName) => (
+  prevDeps?.[depName]?.[firstName]?.[secondName]
+    !== nextDeps?.[depName]?.[firstName]?.[secondName]
+);
+const shallowDiffByChannelWithKeys = (prevDeps, nextDeps, depName, firstName, secondName, keys) => keys.some(
+  k => (
+    prevDeps?.[depName]?.[firstName]?.[secondName]?.[k]
+        !== nextDeps?.[depName]?.[firstName]?.[secondName]?.[k]
+  ),
+);
+const shallowDiffByLayerCoordination = (prevDeps, nextDeps, depName, layerScope) => (
+  prevDeps?.[depName]?.[0]?.[layerScope]
+    !== nextDeps?.[depName]?.[0]?.[layerScope]
+);
+const shallowDiffByLayerCoordinationWithKeys = (prevDeps, nextDeps, depName, layerScope, keys) => keys.some(
+  k => prevDeps?.[depName]?.[0]?.[layerScope]?.[k]
+        !== nextDeps?.[depName]?.[0]?.[layerScope]?.[k],
+);
+const shallowDiffByChannelCoordination = (prevDeps, nextDeps, depName, layerScope, channelScope) => (
+  prevDeps?.[depName]?.[0]?.[layerScope]?.[channelScope]
+    !== nextDeps?.[depName]?.[0]?.[layerScope]?.[channelScope]
+);
+const shallowDiffByChannelCoordinationWithKeys = (prevDeps, nextDeps, depName, layerScope, channelScope, keys) => keys.some(
+  k => prevDeps?.[depName]?.[0]?.[layerScope]?.[channelScope]?.[k]
+        !== nextDeps?.[depName]?.[0]?.[layerScope]?.[channelScope]?.[k],
+);
+
+// We need a custom equality function, to handle the nested nature of the dependencies.
+// We only want to trigger a re-render if the list of layers/channels themselves changed,
+// or if the nested properties (but only those that the colors rely on) for any of them changed.
+// Note: if additional properties become relevant for determining cell colors,
+// this function will need to be updated to stay in sync with that logic.
+export function customIsEqualForCellColors(prevDeps, nextDeps) {
+  let forceUpdate = false;
+
+  // We create curried variants so we don't have to constantly pass prevDeps and nextDeps.
+  const curriedShallowDiff = depName => shallowDiff(prevDeps, nextDeps, depName);
+  const curriedShallowDiffByLayer = (depName, scopeName) => shallowDiffByLayer(prevDeps, nextDeps, depName, scopeName);
+  const curriedShallowDiffByChannel = (depName, firstName, secondName) => shallowDiffByChannel(prevDeps, nextDeps, depName, firstName, secondName);
+  const curriedShallowDiffByChannelWithKeys = (depName, firstName, secondName, keys) => shallowDiffByChannelWithKeys(prevDeps, nextDeps, depName, firstName, secondName, keys);
+  const curriedShallowDiffByLayerCoordination = (depName, layerScope) => shallowDiffByLayerCoordination(prevDeps, nextDeps, depName, layerScope);
+  const curriedShallowDiffByLayerCoordinationWithKeys = (depName, layerScope, keys) => shallowDiffByLayerCoordinationWithKeys(prevDeps, nextDeps, depName, layerScope, keys);
+  const curriedShallowDiffByChannelCoordination = (depName, layerScope, channelScope) => shallowDiffByChannelCoordination(prevDeps, nextDeps, depName, layerScope, channelScope);
+  const curriedShallowDiffByChannelCoordinationWithKeys = (depName, layerScope, channelScope, keys) => shallowDiffByChannelCoordinationWithKeys(prevDeps, nextDeps, depName, layerScope, channelScope, keys);
+
+  // Check if the theme changed, which could change the cell colors even if the underlying data didn't change.
+  if (curriedShallowDiff('theme')) {
+    forceUpdate = true;
+  }
+
+  // Segmentation sets data.
+  if (['segmentationLayerScopes', 'segmentationChannelScopesByLayer'].some(curriedShallowDiff)) {
+    // Force update for all layers since the layerScopes array changed.
+    forceUpdate = true;
+  } else {
+    // Iterate over layers and channels.
+    nextDeps.segmentationLayerScopes?.forEach((layerScope) => {
+      nextDeps.segmentationChannelScopesByLayer?.[layerScope]?.forEach((channelScope) => {
+        if (
+          curriedShallowDiffByChannelWithKeys('obsSegmentationsSetsData', layerScope, channelScope, [
+            'obsSets', 'obsIndex',
+          ])
+            || curriedShallowDiffByChannelCoordinationWithKeys('segmentationChannelCoordination', layerScope, channelScope, [
+              'obsSetColor',
+              'obsColorEncoding',
+              'obsSetSelection',
+              'additionalObsSets',
+            ])
+        ) {
+          forceUpdate = true;
+        }
+      });
+    });
+  }
+
+  // Return "isEqual" value.
+  // (If forceUpdate is true, then isEqual should be false to trigger a re-render.)
+  return !forceUpdate;
+}
+
+export function customIsEqualForInitialViewerState(prevDeps, nextDeps) {
+  let forceUpdate = false;
+
+  // We create curried variants so we don't have to constantly pass prevDeps and nextDeps.
+  const curriedShallowDiff = depName => shallowDiff(prevDeps, nextDeps, depName);
+  const curriedShallowDiffByLayer = (depName, scopeName) => shallowDiffByLayer(prevDeps, nextDeps, depName, scopeName);
+  const curriedShallowDiffByLayerWithKeys = (depName, scopeName, keys) => shallowDiffByLayerWithKeys(prevDeps, nextDeps, depName, scopeName, keys);
+  const curriedShallowDiffByChannel = (depName, firstName, secondName) => shallowDiffByChannel(prevDeps, nextDeps, depName, firstName, secondName);
+  const curriedShallowDiffByChannelWithKeys = (depName, firstName, secondName, keys) => shallowDiffByChannelWithKeys(prevDeps, nextDeps, depName, firstName, secondName, keys);
+  const curriedShallowDiffByLayerCoordination = (depName, layerScope) => shallowDiffByLayerCoordination(prevDeps, nextDeps, depName, layerScope);
+  const curriedShallowDiffByLayerCoordinationWithKeys = (depName, layerScope, keys) => shallowDiffByLayerCoordinationWithKeys(prevDeps, nextDeps, depName, layerScope, keys);
+  const curriedShallowDiffByChannelCoordination = (depName, layerScope, channelScope) => shallowDiffByChannelCoordination(prevDeps, nextDeps, depName, layerScope, channelScope);
+  const curriedShallowDiffByChannelCoordinationWithKeys = (depName, layerScope, channelScope, keys) => shallowDiffByChannelCoordinationWithKeys(prevDeps, nextDeps, depName, layerScope, channelScope, keys);
+
+  // Segmentation layers/channels.
+  if (['segmentationLayerScopes', 'segmentationChannelScopesByLayer'].some(curriedShallowDiff)) {
+    // Force update for all layers since the layerScopes array changed.
+    forceUpdate = true;
+  } else {
+    // Iterate over layers and channels.
+    nextDeps.segmentationLayerScopes?.forEach((layerScope) => {
+      if (
+        curriedShallowDiffByLayer('obsSegmentationsData', layerScope)
+          || curriedShallowDiffByLayerCoordinationWithKeys('segmentationLayerCoordination', layerScope, [
+            'spatialLayerVisible',
+          ])
+      ) {
+        forceUpdate = true;
+      }
+      nextDeps.segmentationChannelScopesByLayer?.[layerScope]?.forEach((channelScope) => {
+        if (
+          curriedShallowDiffByChannelCoordinationWithKeys('segmentationChannelCoordination', layerScope, channelScope, [
+            'spatialChannelVisible',
+          ])
+        ) {
+          forceUpdate = true;
+        }
+      });
+    });
+  }
+
+  // Point layers.
+  if (curriedShallowDiff('pointLayerScopes')) {
+    // Force update for all layers since the layerScopes array changed.
+    forceUpdate = true;
+  } else {
+    // Iterate over layers and channels.
+    nextDeps.pointLayerScopes?.forEach((layerScope) => {
+      if (
+        curriedShallowDiffByLayer('obsPointsData', layerScope)
+          || curriedShallowDiffByLayer('pointMultiIndicesData', layerScope)
+          || curriedShallowDiffByLayerCoordinationWithKeys('pointLayerCoordination', layerScope, [
+            'spatialLayerVisible',
+            'obsColorEncoding',
+            'spatialLayerColor',
+            'featureSelection',
+            'featureFilterMode',
+            'featureColor',
+          ])
+          // For opacity, use an epsilon comparison to avoid too many re-renders, as it affects performance.
+          || (
+            Math.abs(prevDeps?.pointLayerCoordination?.[0]?.[layerScope]?.spatialLayerOpacity - nextDeps?.pointLayerCoordination?.[0]?.[layerScope]?.spatialLayerOpacity)
+            >= 0.05
+          )
+      ) {
+        forceUpdate = true;
+      }
+    });
+  }
+
+  // Return "isEqual" value.
+  // (If forceUpdate is true, then isEqual should be false to trigger a re-render.)
+  return !forceUpdate;
+}

package/dist-tsc/data-hook-ng-utils.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=data-hook-ng-utils.test.d.ts.map

package/dist-tsc/data-hook-ng-utils.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"data-hook-ng-utils.test.d.ts","sourceRoot":"","sources":["../src/data-hook-ng-utils.test.js"],"names":[],"mappings":""}

package/dist-tsc/data-hook-ng-utils.test.js

@@ -1,35 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { extractDataTypeEntities, DEFAULT_NG_PROPS, } from './data-hook-ng-utils.js';
-describe('extractDataTypeEntities (minimal tests)', () => {
-    it('returns empty array when internMap is missing or invalid', () => {
-        expect(extractDataTypeEntities({}, 'A', 'obsSegmentations')).toEqual([]);
-        expect(extractDataTypeEntities({ A: { loaders: {} } }, 'A', 'obsSegmentations')).toEqual([]);
-        expect(extractDataTypeEntities({ A: { loaders: { obsSegmentations: {} } } }, 'A', 'obsSegmentations')).toEqual([]);
-    });
-    it('builds an entity for a precomputed loader and applies sane defaults', () => {
-        const key = { fileUid: 'melanoma-meshes' };
-        const loader = {
-            fileType: 'obsSegmentations.ng-precomputed',
-            url: 'https://www.example.com/example/example_meshes',
-            options: { projectionScale: 2048 },
-        };
-        const internMap = new Map([[key, loader]]);
-        const loaders = { A: { loaders: { obsSegmentations: internMap } } };
-        const out = extractDataTypeEntities(loaders, 'A', 'obsSegmentations');
-        expect(out).toHaveLength(1);
-        const e = out[0];
-        expect(e.key).toBe(key);
-        expect(e.type).toBe('segmentation');
-        expect(e.fileUid).toBe('melanoma-meshes');
-        expect(e.layout).toBe(DEFAULT_NG_PROPS.layout);
-        // URL + source prefixing
-        expect(e.url).toBe(loader.url);
-        expect(e.source).toBe('precomputed://https://www.example.com/example/example_meshes');
-        expect(e.dimensions).toEqual({ x: [1, 'nm'], y: [1, 'nm'], z: [1, 'nm'] });
-        // camera defaults + single override
-        expect(e.position).toEqual(DEFAULT_NG_PROPS.position);
-        expect(e.projectionOrientation).toEqual(DEFAULT_NG_PROPS.projectionOrientation);
-        expect(e.projectionScale).toBe(2048);
-        expect(e.crossSectionScale).toBe(DEFAULT_NG_PROPS.crossSectionScale);
-    });
-});