@vitessce/spatial-utils 3.1.2 → 3.1.3

package/dist/{deflate-6fd0bca9.js → deflate-e2811f40.js}

@@ -1,5 +1,5 @@
 import { i as inflate_1 } from "./pako.esm-68f84e2a.js";
-import { B as BaseDecoder } from "./index-551fa504.js";
+import { B as BaseDecoder } from "./index-e86d2626.js";
 import "react";
 class DeflateDecoder extends BaseDecoder {
   decodeBlock(buffer) {

package/dist/{index-551fa504.js → index-e86d2626.js}

@@ -133297,16 +133297,16 @@ function addDecoder(cases, importFn) {
   }
   cases.forEach((c) => registry$1.set(c, importFn));
 }
-addDecoder([void 0, 1], () => import("./raw-8e22b1c4.js").then((m) => m.default));
-addDecoder(5, () => import("./lzw-c3783269.js").then((m) => m.default));
+addDecoder([void 0, 1], () => import("./raw-01deac62.js").then((m) => m.default));
+addDecoder(5, () => import("./lzw-61ae68b2.js").then((m) => m.default));
 addDecoder(6, () => {
   throw new Error("old style JPEG compression is not supported.");
 });
-addDecoder(7, () => import("./jpeg-d67d9d82.js").then((m) => m.default));
-addDecoder([8, 32946], () => import("./deflate-6fd0bca9.js").then((m) => m.default));
-addDecoder(32773, () => import("./packbits-209c03d7.js").then((m) => m.default));
-addDecoder(34887, () => import("./lerc-522345a3.js").then((m) => m.default));
-addDecoder(50001, () => import("./webimage-a5d2769c.js").then((m) => m.default));
+addDecoder(7, () => import("./jpeg-03b93228.js").then((m) => m.default));
+addDecoder([8, 32946], () => import("./deflate-e2811f40.js").then((m) => m.default));
+addDecoder(32773, () => import("./packbits-b1d8eca2.js").then((m) => m.default));
+addDecoder(34887, () => import("./lerc-d5a641c1.js").then((m) => m.default));
+addDecoder(50001, () => import("./webimage-f6e6dcb0.js").then((m) => m.default));
 function decodeRowAcc(row, stride) {
   let length2 = row.length - stride;
   let offset = 0;
@@ -144475,6 +144475,41 @@ function coordinateTransformationsToMatrix(coordinateTransformations, axes) {
   }
   return mat;
 }
+function normalizeCoordinateTransformations(coordinateTransformations, datasets) {
+  var _a2;
+  let result = [];
+  if (Array.isArray(coordinateTransformations)) {
+    result = coordinateTransformations.map((transform2) => {
+      if (transform2.input && transform2.output) {
+        const { type } = transform2;
+        if (type === "translation") {
+          return {
+            type,
+            translation: transform2.translation
+          };
+        }
+        if (type === "scale") {
+          return {
+            type,
+            scale: transform2.scale
+          };
+        }
+        if (type === "identity") {
+          return { type };
+        }
+        console.warn(`Coordinate transformation type "${type}" is not supported.`);
+      }
+      return transform2;
+    });
+  }
+  if (Array.isArray((_a2 = datasets == null ? void 0 : datasets[0]) == null ? void 0 : _a2.coordinateTransformations)) {
+    result = [
+      ...datasets[0].coordinateTransformations,
+      ...result
+    ];
+  }
+  return result;
+}
 export {
   BaseDecoder as B,
   DEFAULT_CELLS_LAYER as D,
@@ -144493,5 +144528,6 @@ export {
   getNgffAxes as l,
   getNgffAxesForTiff as m,
   coordinateTransformationsToMatrix as n,
+  normalizeCoordinateTransformations as o,
   square as s
 };

package/dist/index.js

@@ -1,4 +1,4 @@
-import { D, e, a, b, c, d, G, n, l, m, h, i, f, j, k, s } from "./index-551fa504.js";
+import { D, e, a, b, c, d, G, n, l, m, h, i, f, j, k, o, s } from "./index-e86d2626.js";
 import "react";
 export {
   D as DEFAULT_CELLS_LAYER,
@@ -16,5 +16,6 @@ export {
   f as initializeRasterLayersAndChannels,
   j as isInterleaved,
   k as isRgb,
+  o as normalizeCoordinateTransformations,
   s as square
 };

package/dist/{jpeg-d67d9d82.js → jpeg-03b93228.js}

@@ -1,4 +1,4 @@
-import { B as BaseDecoder } from "./index-551fa504.js";
+import { B as BaseDecoder } from "./index-e86d2626.js";
 import "react";
 const dctZigZag = new Int32Array([
   0,

package/dist/{lerc-522345a3.js → lerc-d5a641c1.js}

@@ -1,5 +1,5 @@
 import { i as inflate_1 } from "./pako.esm-68f84e2a.js";
-import { g as getDefaultExportFromCjs, B as BaseDecoder } from "./index-551fa504.js";
+import { g as getDefaultExportFromCjs, B as BaseDecoder } from "./index-e86d2626.js";
 import "react";
 const LercParameters = {
   Version: 0,

package/dist/{lzw-c3783269.js → lzw-61ae68b2.js}

@@ -1,4 +1,4 @@
-import { B as BaseDecoder } from "./index-551fa504.js";
+import { B as BaseDecoder } from "./index-e86d2626.js";
 import "react";
 const MIN_BITS = 9;
 const CLEAR_CODE = 256;

package/dist/{packbits-209c03d7.js → packbits-b1d8eca2.js}

@@ -1,4 +1,4 @@
-import { B as BaseDecoder } from "./index-551fa504.js";
+import { B as BaseDecoder } from "./index-e86d2626.js";
 import "react";
 class PackbitsDecoder extends BaseDecoder {
   decodeBlock(buffer) {

package/dist/{raw-8e22b1c4.js → raw-01deac62.js}

@@ -1,4 +1,4 @@
-import { B as BaseDecoder } from "./index-551fa504.js";
+import { B as BaseDecoder } from "./index-e86d2626.js";
 import "react";
 class RawDecoder extends BaseDecoder {
   decodeBlock(buffer) {

package/dist/{webimage-a5d2769c.js → webimage-f6e6dcb0.js}

@@ -1,4 +1,4 @@
-import { B as BaseDecoder } from "./index-551fa504.js";
+import { B as BaseDecoder } from "./index-e86d2626.js";
 import "react";
 class WebImageDecoder extends BaseDecoder {
   constructor() {

package/dist-tsc/index.d.ts

@@ -1,2 +1,2 @@
-export { GLOBAL_LABELS, DEFAULT_CELLS_LAYER, DEFAULT_MOLECULES_LAYER, DEFAULT_NEIGHBORHOODS_LAYER, DEFAULT_RASTER_DOMAIN_TYPE, DEFAULT_RASTER_LAYER_PROPS, DEFAULT_LAYER_TYPE_ORDERING, square, initializeLayerChannels, initializeRasterLayersAndChannels, getSourceFromLoader, isInterleaved, isRgb, getNgffAxes, getNgffAxesForTiff, coordinateTransformationsToMatrix } from "./spatial.js";
+export { GLOBAL_LABELS, DEFAULT_CELLS_LAYER, DEFAULT_MOLECULES_LAYER, DEFAULT_NEIGHBORHOODS_LAYER, DEFAULT_RASTER_DOMAIN_TYPE, DEFAULT_RASTER_LAYER_PROPS, DEFAULT_LAYER_TYPE_ORDERING, square, initializeLayerChannels, initializeRasterLayersAndChannels, getSourceFromLoader, isInterleaved, isRgb, getNgffAxes, getNgffAxesForTiff, coordinateTransformationsToMatrix, normalizeCoordinateTransformations } from "./spatial.js";
 //# sourceMappingURL=index.d.ts.map

package/dist-tsc/index.js

@@ -1 +1 @@
-export { GLOBAL_LABELS, DEFAULT_CELLS_LAYER, DEFAULT_MOLECULES_LAYER, DEFAULT_NEIGHBORHOODS_LAYER, DEFAULT_RASTER_DOMAIN_TYPE, DEFAULT_RASTER_LAYER_PROPS, DEFAULT_LAYER_TYPE_ORDERING, square, initializeLayerChannels, initializeRasterLayersAndChannels, getSourceFromLoader, isInterleaved, isRgb, getNgffAxes, getNgffAxesForTiff, coordinateTransformationsToMatrix, } from './spatial.js';
+export { GLOBAL_LABELS, DEFAULT_CELLS_LAYER, DEFAULT_MOLECULES_LAYER, DEFAULT_NEIGHBORHOODS_LAYER, DEFAULT_RASTER_DOMAIN_TYPE, DEFAULT_RASTER_LAYER_PROPS, DEFAULT_LAYER_TYPE_ORDERING, square, initializeLayerChannels, initializeRasterLayersAndChannels, getSourceFromLoader, isInterleaved, isRgb, getNgffAxes, getNgffAxesForTiff, coordinateTransformationsToMatrix, normalizeCoordinateTransformations, } from './spatial.js';

package/dist-tsc/spatial.d.ts

@@ -51,6 +51,17 @@ export function getNgffAxesForTiff(dimOrder: any): any;
  * @returns {Array<number>} Array of 16 numbers representing the Matrix4.
  */
 export function coordinateTransformationsToMatrix(coordinateTransformations: object[], axes: object[]): Array<number>;
+/**
+ * Normalize coordinate transformations to the OME-NGFF v0.4 format,
+ * despite potentially being in the new format proposed in
+ * https://github.com/ome/ngff/pull/138 (As of 2023-09-02).
+ * @param {object[]|undefined} coordinateTransformations Value of
+ * multiscales[0].coordinateTransformations in either OME-NGFF v0.4 format
+ * or that proposed in https://github.com/ome/ngff/pull/138.
+ * @param {object[]} datasets Value of multiscales[0].datasets in OME-NGFF v0.4 format.
+ * @returns {object[]} Array of coordinateTransformations in OME-NGFF v0.4 format.
+ */
+export function normalizeCoordinateTransformations(coordinateTransformations: object[] | undefined, datasets: object[]): object[];
 export const GLOBAL_LABELS: string[];
 export const DEFAULT_RASTER_DOMAIN_TYPE: "Min/Max";
 export namespace DEFAULT_RASTER_LAYER_PROPS {

package/dist-tsc/spatial.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spatial.d.ts","sourceRoot":"","sources":["../src/spatial.js"],"names":[],"mappings":"AAOA,wDAEC;AAiCD;;;;;;GAMG;AACH,4CAJW,MAAM,UACN,MAAM,eACJ,MAAM,CAMlB;AAED;;;;GAIG;AACH,8BAHW,MAAM,YACN,QAAM,IAAI,WAiBpB;AAmHD;;GAEG;AACH,qCAFW,MAAO,MAAM,CAAC,WAKxB;AAED;;;;;;GAMG;AACH,gDALW,MAAM,eAEJ,MAAM,EAAE,CAuCpB;AAED;;;;;;;;;GASG;AACH,gEAJW,MAAM,EAAE,sBAER,CAAC,MAAM,EAAE,GAAC,IAAI,CAAC,+CAuEzB;AASD;;;IAuBC;AAED,uDAQC;AAED;;;;;;;;GAQG;AACH,6EANW,MAAM,EAAE,QAER,MAAM,EAAE,GAEN,MAAM,MAAM,CAAC,CA4CzB;AAtZD,qCAAwC;AAExC,mDAAoD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsBpD,mDAKE"}
+{"version":3,"file":"spatial.d.ts","sourceRoot":"","sources":["../src/spatial.js"],"names":[],"mappings":"AAOA,wDAEC;AAiCD;;;;;;GAMG;AACH,4CAJW,MAAM,UACN,MAAM,eACJ,MAAM,CAMlB;AAED;;;;GAIG;AACH,8BAHW,MAAM,YACN,QAAM,IAAI,WAiBpB;AAmHD;;GAEG;AACH,qCAFW,MAAO,MAAM,CAAC,WAKxB;AAED;;;;;;GAMG;AACH,gDALW,MAAM,eAEJ,MAAM,EAAE,CAuCpB;AAED;;;;;;;;;GASG;AACH,gEAJW,MAAM,EAAE,sBAER,CAAC,MAAM,EAAE,GAAC,IAAI,CAAC,+CAuEzB;AASD;;;IAuBC;AAED,uDAQC;AAED;;;;;;;;GAQG;AACH,6EANW,MAAM,EAAE,QAER,MAAM,EAAE,GAEN,MAAM,MAAM,CAAC,CA4CzB;AAED;;;;;;;;;GASG;AACH,8EANW,MAAM,EAAE,GAAC,SAAS,YAGlB,MAAM,EAAE,GACN,MAAM,EAAE,CAiDpB;AAjdD,qCAAwC;AAExC,mDAAoD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsBpD,mDAKE"}

package/dist-tsc/spatial.js

@@ -373,3 +373,58 @@ export function coordinateTransformationsToMatrix(coordinateTransformations, axe
     }
     return mat;
 }
+/**
+ * Normalize coordinate transformations to the OME-NGFF v0.4 format,
+ * despite potentially being in the new format proposed in
+ * https://github.com/ome/ngff/pull/138 (As of 2023-09-02).
+ * @param {object[]|undefined} coordinateTransformations Value of
+ * multiscales[0].coordinateTransformations in either OME-NGFF v0.4 format
+ * or that proposed in https://github.com/ome/ngff/pull/138.
+ * @param {object[]} datasets Value of multiscales[0].datasets in OME-NGFF v0.4 format.
+ * @returns {object[]} Array of coordinateTransformations in OME-NGFF v0.4 format.
+ */
+export function normalizeCoordinateTransformations(coordinateTransformations, datasets) {
+    // "The transformations in the list are applied sequentially and in order."
+    // Reference: https://ngff.openmicroscopy.org/0.4/index.html#trafo-md
+    let result = [];
+    if (Array.isArray(coordinateTransformations)) {
+        result = coordinateTransformations.map((transform) => {
+            if (transform.input && transform.output) {
+                // This is a new-style coordinate transformation.
+                // (As proposed in https://github.com/ome/ngff/pull/138)
+                const { type } = transform;
+                if (type === 'translation') {
+                    return {
+                        type,
+                        translation: transform.translation,
+                    };
+                }
+                if (type === 'scale') {
+                    return {
+                        type,
+                        scale: transform.scale,
+                    };
+                }
+                if (type === 'identity') {
+                    return { type };
+                }
+                console.warn(`Coordinate transformation type "${type}" is not supported.`);
+            }
+            // Assume it was already an old-style (NGFF v0.4) coordinate transformation.
+            return transform;
+        });
+    }
+    if (Array.isArray(datasets?.[0]?.coordinateTransformations)) {
+        // "Datasets SHOULD define a transformation from array space
+        // to their "native physical space."
+        // This transformation SHOULD describe physical pixel spacing
+        // and origin only, and therefore SHOULD consist of
+        // `scale` and/or `translation` types only.""
+        // Reference: https://github.com/ome/ngff/blob/b92f540dc95440f2d6b7012185b09c2b862aa744/latest/transform-details.bs#L99
+        result = [
+            ...datasets[0].coordinateTransformations,
+            ...result,
+        ];
+    }
+    return result;
+}

package/dist-tsc/spatial.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { square, coordinateTransformationsToMatrix } from './spatial.js';
+import { square, coordinateTransformationsToMatrix, normalizeCoordinateTransformations, } from './spatial.js';
 const defaultAxes = [
     { type: 'time', name: 't' },
     { type: 'channel', name: 'c' },
@@ -41,4 +41,159 @@ describe('Spatial.js', () => {
             ]);
         });
     });
+    describe('normalizeCoordinateTransformations', () => {
+        it('does nothing for OME-NGFF v0.4 input', () => {
+            const datasets = [
+                {
+                    coordinateTransformations: [
+                        {
+                            scale: [
+                                1,
+                                0.5002025531914894,
+                                0.3603981534640209,
+                                0.3603981534640209,
+                            ],
+                            type: 'scale',
+                        },
+                    ],
+                    path: '0',
+                },
+                {
+                    coordinateTransformations: [
+                        {
+                            scale: [
+                                1,
+                                0.5002025531914894,
+                                0.7207963069280418,
+                                0.7207963069280418,
+                            ],
+                            type: 'scale',
+                        },
+                    ],
+                    path: '1',
+                },
+                {
+                    coordinateTransformations: [
+                        {
+                            scale: [
+                                1,
+                                0.5002025531914894,
+                                1.4415926138560835,
+                                1.4415926138560835,
+                            ],
+                            type: 'scale',
+                        },
+                    ],
+                    path: '2',
+                },
+            ];
+            expect(normalizeCoordinateTransformations(undefined, datasets)).toEqual([
+                // Here, we expect only the first dataset to be used.
+                // However, we should eventually support transforms
+                // specified for each dataset individually,
+                // since there could in theory be irregular ways of downsampling.
+                {
+                    scale: [
+                        1,
+                        0.5002025531914894,
+                        0.3603981534640209,
+                        0.3603981534640209,
+                    ],
+                    type: 'scale',
+                },
+            ]);
+        });
+        it('transforms SpatialData input', () => {
+            const newCoordinateTransformations = [
+                {
+                    input: {
+                        axes: [
+                            {
+                                name: 'c',
+                                type: 'channel',
+                            },
+                            {
+                                name: 'y',
+                                type: 'space',
+                                unit: 'unit',
+                            },
+                            {
+                                name: 'x',
+                                type: 'space',
+                                unit: 'unit',
+                            },
+                        ],
+                        name: 'cyx',
+                    },
+                    output: {
+                        axes: [
+                            {
+                                name: 'c',
+                                type: 'channel',
+                            },
+                            {
+                                name: 'y',
+                                type: 'space',
+                                unit: 'unit',
+                            },
+                            {
+                                name: 'x',
+                                type: 'space',
+                                unit: 'unit',
+                            },
+                        ],
+                        name: 'ST8059048',
+                    },
+                    scale: [
+                        1.0,
+                        8.670500183814605,
+                        8.670500183814605,
+                    ],
+                    type: 'scale',
+                },
+            ];
+            const datasets = [
+                {
+                    coordinateTransformations: [
+                        {
+                            scale: [
+                                1.0,
+                                1.0,
+                                1.0,
+                            ],
+                            type: 'scale',
+                        },
+                    ],
+                    path: '0',
+                },
+            ];
+            expect(normalizeCoordinateTransformations(newCoordinateTransformations, datasets)).toEqual([
+                // Here, we expect only the first dataset to be used.
+                // However, we should eventually support transforms
+                // specified for each dataset individually,
+                // since there could in theory be irregular ways of downsampling.
+                {
+                    scale: [
+                        1.0,
+                        1.0,
+                        1.0,
+                    ],
+                    type: 'scale',
+                },
+                // We expect the dataset transform to be prepended
+                // to the newCoordinateTransformations items.
+                // We do not check the input/output coordinate systems, but we should eventually allow
+                // the user to specify this somehow and use that information to filter which transforms
+                // are included here.
+                {
+                    scale: [
+                        1.0,
+                        8.670500183814605,
+                        8.670500183814605,
+                    ],
+                    type: 'scale',
+                },
+            ]);
+        });
+    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vitessce/spatial-utils",
-  "version": "3.1.2",
+  "version": "3.1.3",
   "author": "Gehlenborg Lab",
   "homepage": "http://vitessce.io",
   "repository": {
@@ -19,8 +19,8 @@
     "lodash-es": "^4.17.21",
     "math.gl": "^3.5.6",
     "mathjs": "^9.2.0",
-    "@vitessce/gl": "3.1.2",
-    "@vitessce/utils": "3.1.2"
+    "@vitessce/gl": "3.1.3",
+    "@vitessce/utils": "3.1.3"
   },
   "scripts": {
     "bundle": "pnpm exec vite build -c ../../../scripts/vite.config.js",

package/src/index.js

@@ -15,4 +15,5 @@ export {
   getNgffAxes,
   getNgffAxesForTiff,
   coordinateTransformationsToMatrix,
+  normalizeCoordinateTransformations,
 } from './spatial.js';

package/src/spatial.js

@@ -416,3 +416,62 @@ export function coordinateTransformationsToMatrix(coordinateTransformations, axe
   }
   return mat;
 }
+
+/**
+ * Normalize coordinate transformations to the OME-NGFF v0.4 format,
+ * despite potentially being in the new format proposed in
+ * https://github.com/ome/ngff/pull/138 (As of 2023-09-02).
+ * @param {object[]|undefined} coordinateTransformations Value of
+ * multiscales[0].coordinateTransformations in either OME-NGFF v0.4 format
+ * or that proposed in https://github.com/ome/ngff/pull/138.
+ * @param {object[]} datasets Value of multiscales[0].datasets in OME-NGFF v0.4 format.
+ * @returns {object[]} Array of coordinateTransformations in OME-NGFF v0.4 format.
+ */
+export function normalizeCoordinateTransformations(coordinateTransformations, datasets) {
+  // "The transformations in the list are applied sequentially and in order."
+  // Reference: https://ngff.openmicroscopy.org/0.4/index.html#trafo-md
+  let result = [];
+
+  if (Array.isArray(coordinateTransformations)) {
+    result = coordinateTransformations.map((transform) => {
+      if (transform.input && transform.output) {
+        // This is a new-style coordinate transformation.
+        // (As proposed in https://github.com/ome/ngff/pull/138)
+        const { type } = transform;
+        if (type === 'translation') {
+          return {
+            type,
+            translation: transform.translation,
+          };
+        }
+        if (type === 'scale') {
+          return {
+            type,
+            scale: transform.scale,
+          };
+        }
+        if (type === 'identity') {
+          return { type };
+        }
+        console.warn(`Coordinate transformation type "${type}" is not supported.`);
+      }
+      // Assume it was already an old-style (NGFF v0.4) coordinate transformation.
+      return transform;
+    });
+  }
+
+  if (Array.isArray(datasets?.[0]?.coordinateTransformations)) {
+    // "Datasets SHOULD define a transformation from array space
+    // to their "native physical space."
+    // This transformation SHOULD describe physical pixel spacing
+    // and origin only, and therefore SHOULD consist of
+    // `scale` and/or `translation` types only.""
+    // Reference: https://github.com/ome/ngff/blob/b92f540dc95440f2d6b7012185b09c2b862aa744/latest/transform-details.bs#L99
+
+    result = [
+      ...datasets[0].coordinateTransformations,
+      ...result,
+    ];
+  }
+  return result;
+}

package/src/spatial.test.js

@@ -1,5 +1,9 @@
 import { describe, it, expect } from 'vitest';
-import { square, coordinateTransformationsToMatrix } from './spatial.js';
+import {
+  square,
+  coordinateTransformationsToMatrix,
+  normalizeCoordinateTransformations,
+} from './spatial.js';
 
 const defaultAxes = [
   { type: 'time', name: 't' },
@@ -43,4 +47,159 @@ describe('Spatial.js', () => {
       ]);
     });
   });
+  describe('normalizeCoordinateTransformations', () => {
+    it('does nothing for OME-NGFF v0.4 input', () => {
+      const datasets = [
+        {
+          coordinateTransformations: [
+            {
+              scale: [
+                1,
+                0.5002025531914894,
+                0.3603981534640209,
+                0.3603981534640209,
+              ],
+              type: 'scale',
+            },
+          ],
+          path: '0',
+        },
+        {
+          coordinateTransformations: [
+            {
+              scale: [
+                1,
+                0.5002025531914894,
+                0.7207963069280418,
+                0.7207963069280418,
+              ],
+              type: 'scale',
+            },
+          ],
+          path: '1',
+        },
+        {
+          coordinateTransformations: [
+            {
+              scale: [
+                1,
+                0.5002025531914894,
+                1.4415926138560835,
+                1.4415926138560835,
+              ],
+              type: 'scale',
+            },
+          ],
+          path: '2',
+        },
+      ];
+      expect(normalizeCoordinateTransformations(undefined, datasets)).toEqual([
+        // Here, we expect only the first dataset to be used.
+        // However, we should eventually support transforms
+        // specified for each dataset individually,
+        // since there could in theory be irregular ways of downsampling.
+        {
+          scale: [
+            1,
+            0.5002025531914894,
+            0.3603981534640209,
+            0.3603981534640209,
+          ],
+          type: 'scale',
+        },
+      ]);
+    });
+    it('transforms SpatialData input', () => {
+      const newCoordinateTransformations = [
+        {
+          input: {
+            axes: [
+              {
+                name: 'c',
+                type: 'channel',
+              },
+              {
+                name: 'y',
+                type: 'space',
+                unit: 'unit',
+              },
+              {
+                name: 'x',
+                type: 'space',
+                unit: 'unit',
+              },
+            ],
+            name: 'cyx',
+          },
+          output: {
+            axes: [
+              {
+                name: 'c',
+                type: 'channel',
+              },
+              {
+                name: 'y',
+                type: 'space',
+                unit: 'unit',
+              },
+              {
+                name: 'x',
+                type: 'space',
+                unit: 'unit',
+              },
+            ],
+            name: 'ST8059048',
+          },
+          scale: [
+            1.0,
+            8.670500183814605,
+            8.670500183814605,
+          ],
+          type: 'scale',
+        },
+      ];
+      const datasets = [
+        {
+          coordinateTransformations: [
+            {
+              scale: [
+                1.0,
+                1.0,
+                1.0,
+              ],
+              type: 'scale',
+            },
+          ],
+          path: '0',
+        },
+      ];
+      expect(normalizeCoordinateTransformations(newCoordinateTransformations, datasets)).toEqual([
+        // Here, we expect only the first dataset to be used.
+        // However, we should eventually support transforms
+        // specified for each dataset individually,
+        // since there could in theory be irregular ways of downsampling.
+        {
+          scale: [
+            1.0,
+            1.0,
+            1.0,
+          ],
+          type: 'scale',
+        },
+        // We expect the dataset transform to be prepended
+        // to the newCoordinateTransformations items.
+        // We do not check the input/output coordinate systems, but we should eventually allow
+        // the user to specify this somehow and use that information to filter which transforms
+        // are included here.
+        {
+          scale: [
+            1.0,
+            8.670500183814605,
+            8.670500183814605,
+          ],
+          type: 'scale',
+        },
+      ]);
+    });
+  });
 });