@vitessce/config 3.0.0 → 3.1.0

package/dist/index.js

@@ -93,6 +93,10 @@ const FileType$1 = {
   ANNDATA_EXPRESSION_MATRIX_ZARR: "anndata-expression-matrix.zarr"
 };
 const CoordinationType$1 = {
+  // Meta coordination scopes
+  META_COORDINATION_SCOPES: "metaCoordinationScopes",
+  META_COORDINATION_SCOPES_BY: "metaCoordinationScopesBy",
+  // Other coordination scopes
   DATASET: "dataset",
   // Entity types
   OBS_TYPE: "obsType",
@@ -15245,6 +15249,72 @@ class VitessceConfigDataset {
     };
   }
 }
+function useComplexCoordinationHelper(scopes, coordinationScopes, coordinationScopesBy) {
+  function processLevel(parentType, parentScope, levelType, levelVal) {
+    var _a, _b;
+    if (Array.isArray(levelVal)) {
+      coordinationScopesBy[parentType] = {
+        ...coordinationScopesBy[parentType] || {},
+        [levelType]: {
+          ...((_a = coordinationScopesBy[parentType]) == null ? void 0 : _a[levelType]) || {},
+          [parentScope.cScope]: levelVal.map((childVal) => childVal.scope.cScope)
+        }
+      };
+      levelVal.forEach((childVal) => {
+        if (childVal.children) {
+          Object.entries(childVal.children).forEach(([nextLevelType, nextLevelVal]) => processLevel(
+            levelType,
+            childVal.scope,
+            nextLevelType,
+            nextLevelVal
+          ));
+        }
+      });
+    } else {
+      coordinationScopesBy[parentType] = {
+        ...coordinationScopesBy[parentType] || {},
+        [levelType]: {
+          ...((_b = coordinationScopesBy[parentType]) == null ? void 0 : _b[levelType]) || {},
+          [parentScope.cScope]: levelVal.scope.cScope
+        }
+      };
+      if (levelVal.children) {
+        Object.entries(levelVal.children).forEach(([nextLevelType, nextLevelVal]) => processLevel(
+          levelType,
+          levelVal.scope,
+          nextLevelType,
+          nextLevelVal
+        ));
+      }
+    }
+  }
+  Object.entries(scopes).forEach(([topLevelType, topLevelVal]) => {
+    if (Array.isArray(topLevelVal)) {
+      coordinationScopes[topLevelType] = topLevelVal.map((levelVal) => levelVal.scope.cScope);
+      topLevelVal.forEach((levelVal) => {
+        if (levelVal.children) {
+          Object.entries(levelVal.children).forEach(([nextLevelType, nextLevelVal]) => processLevel(
+            topLevelType,
+            levelVal.scope,
+            nextLevelType,
+            nextLevelVal
+          ));
+        }
+      });
+    } else {
+      coordinationScopes[topLevelType] = topLevelVal.scope.cScope;
+      if (topLevelVal.children) {
+        Object.entries(topLevelVal.children).forEach(([nextLevelType, nextLevelVal]) => processLevel(
+          topLevelType,
+          topLevelVal.scope,
+          nextLevelType,
+          nextLevelVal
+        ));
+      }
+    }
+  });
+  return [coordinationScopes, coordinationScopesBy];
+}
 class VitessceConfigView {
   /**
    * Construct a new view instance.
@@ -15260,6 +15330,8 @@ class VitessceConfigView {
     this.view = {
       component,
       coordinationScopes,
+      coordinationScopesBy: void 0,
+      // TODO: initialize from parameter?
       x,
       y,
       w,
@@ -15279,6 +15351,41 @@ class VitessceConfigView {
     });
     return this;
   }
+  useComplexCoordination(scopes) {
+    if (!this.view.coordinationScopes) {
+      this.view.coordinationScopes = {};
+    }
+    if (!this.view.coordinationScopesBy) {
+      this.view.coordinationScopesBy = {};
+    }
+    const [nextCoordinationScopes, nextCoordinationScopesBy] = useComplexCoordinationHelper(
+      scopes,
+      this.view.coordinationScopes,
+      this.view.coordinationScopesBy
+    );
+    this.view.coordinationScopes = nextCoordinationScopes;
+    this.view.coordinationScopesBy = nextCoordinationScopesBy;
+    return this;
+  }
+  /**
+   * Attach meta coordination scopes to this view.
+   * @param {VitessceConfigMetaCoordinationScope} metaScope A meta coordination scope instance.
+   * @returns {VitessceConfigView} This, to allow chaining.
+   */
+  useMetaCoordination(metaScope) {
+    if (!this.view.coordinationScopes) {
+      this.view.coordinationScopes = {};
+    }
+    this.view.coordinationScopes[CoordinationType$1.META_COORDINATION_SCOPES] = [
+      ...this.view.coordinationScopes[CoordinationType$1.META_COORDINATION_SCOPES] || [],
+      metaScope.metaScope.cScope
+    ];
+    this.view.coordinationScopes[CoordinationType$1.META_COORDINATION_SCOPES_BY] = [
+      ...this.view.coordinationScopes[CoordinationType$1.META_COORDINATION_SCOPES_BY] || [],
+      metaScope.metaByScope.cScope
+    ];
+    return this;
+  }
   /**
     * Set the x, y, w, h values for this view.
     * @param {number} x The x-coordinate of the view in the layout.
@@ -15330,6 +15437,11 @@ function vconcat(...views) {
   const vcvvc = new VitessceConfigViewVConcat(views);
   return vcvvc;
 }
+class CoordinationLevel {
+  constructor(value) {
+    this.value = value;
+  }
+}
 class VitessceConfigCoordinationScope {
   /**
    * Construct a new coordination scope instance.
@@ -15351,6 +15463,63 @@ class VitessceConfigCoordinationScope {
     return this;
   }
 }
+class VitessceConfigMetaCoordinationScope {
+  /**
+   * Construct a new coordination scope instance.
+   * @param {string} metaScope The name of the coordination scope for metaCoordinationScopes.
+   * @param {string} metaByScope The name of the coordination scope for metaCoordinationScopesBy.
+   */
+  constructor(metaScope, metaByScope) {
+    this.metaScope = new VitessceConfigCoordinationScope(
+      CoordinationType$1.META_COORDINATION_SCOPES,
+      metaScope
+    );
+    this.metaByScope = new VitessceConfigCoordinationScope(
+      CoordinationType$1.META_COORDINATION_SCOPES_BY,
+      metaByScope
+    );
+  }
+  /**
+   * Attach coordination scopes to this meta scope.
+   * @param  {...VitessceConfigCoordinationScope} args A variable number of
+   * coordination scope instances.
+   * @returns {VitessceConfigMetaCoordinationScope} This, to allow chaining.
+   */
+  useCoordination(...args) {
+    const cScopes = args;
+    const metaScopesVal = this.metaScope.cValue;
+    cScopes.forEach((cScope) => {
+      metaScopesVal[cScope.cType] = cScope.cScope;
+    });
+    this.metaScope.setValue(metaScopesVal);
+    return this;
+  }
+  useComplexCoordination(scopes) {
+    if (!this.metaScope.cValue) {
+      this.metaScope.setValue({});
+    }
+    if (!this.metaByScope.cValue) {
+      this.metaByScope.setValue({});
+    }
+    const [metaScopesVal, metaByScopesVal] = useComplexCoordinationHelper(
+      scopes,
+      this.metaScope.cValue,
+      this.metaByScope.cValue
+    );
+    this.metaScope.setValue(metaScopesVal);
+    this.metaByScope.setValue(metaByScopesVal);
+    return this;
+  }
+  /**
+   * Set the coordination value of the coordination scope.
+   * @param {any} cValue The value to set.
+   * @returns {VitessceConfigCoordinationScope} This, to allow chaining.
+   */
+  setValue(cValue) {
+    this.cValue = cValue;
+    return this;
+  }
+}
 class VitessceConfig {
   /**
    * Construct a new view config instance.
@@ -15472,6 +15641,53 @@ class VitessceConfig {
     });
     return result;
   }
+  addMetaCoordination() {
+    const prevMetaScopes = this.config.coordinationSpace[CoordinationType$1.META_COORDINATION_SCOPES] ? Object.keys(this.config.coordinationSpace[CoordinationType$1.META_COORDINATION_SCOPES]) : [];
+    const prevMetaByScopes = this.config.coordinationSpace[CoordinationType$1.META_COORDINATION_SCOPES_BY] ? Object.keys(this.config.coordinationSpace[CoordinationType$1.META_COORDINATION_SCOPES_BY]) : [];
+    const metaContainer = new VitessceConfigMetaCoordinationScope(
+      getNextScope(prevMetaScopes),
+      getNextScope(prevMetaByScopes)
+    );
+    if (!this.config.coordinationSpace[CoordinationType$1.META_COORDINATION_SCOPES]) {
+      this.config.coordinationSpace[CoordinationType$1.META_COORDINATION_SCOPES] = {};
+    }
+    if (!this.config.coordinationSpace[CoordinationType$1.META_COORDINATION_SCOPES_BY]) {
+      this.config.coordinationSpace[CoordinationType$1.META_COORDINATION_SCOPES_BY] = {};
+    }
+    this.config.coordinationSpace[CoordinationType$1.META_COORDINATION_SCOPES][metaContainer.metaScope.cScope] = metaContainer.metaScope;
+    this.config.coordinationSpace[CoordinationType$1.META_COORDINATION_SCOPES_BY][metaContainer.metaByScope.cScope] = metaContainer.metaByScope;
+    return metaContainer;
+  }
+  addComplexCoordination(input) {
+    const processLevel = (level) => {
+      const result = {};
+      Object.entries(level).forEach(([cType, nextLevelOrInitialValue]) => {
+        if (nextLevelOrInitialValue instanceof CoordinationLevel) {
+          const nextLevel = nextLevelOrInitialValue.value;
+          if (Array.isArray(nextLevel)) {
+            result[cType] = nextLevel.map((nextEl) => {
+              const [dummyScope] = this.addCoordination(cType);
+              dummyScope.setValue("__dummy__");
+              return {
+                scope: dummyScope,
+                children: processLevel(nextEl)
+              };
+            });
+          } else {
+            throw new Error("Expected CoordinationLevel.value to be an array.");
+          }
+        } else {
+          const initialValue = nextLevelOrInitialValue;
+          const [scope] = this.addCoordination(cType);
+          scope.setValue(initialValue);
+          result[cType] = { scope };
+        }
+      });
+      return result;
+    };
+    const output = processLevel(input);
+    return output;
+  }
   /**
    * A convenience function for setting up new coordination scopes across a set of views.
    * @param {VitessceConfigView[]} views An array of view objects to link together.
@@ -15584,6 +15800,109 @@ class VitessceConfig {
     return vc;
   }
 }
+const SINGLE_CELL_WITH_HEATMAP_VIEWS = {
+  obsSets: { x: 4, y: 0, w: 4, h: 4 },
+  obsSetSizes: { x: 8, y: 0, w: 4, h: 4 },
+  scatterplot: { x: 0, y: 0, w: 4, h: 4 },
+  heatmap: { x: 0, y: 4, w: 8, h: 4 },
+  featureList: { x: 8, y: 4, w: 4, h: 4 }
+};
+const SINGLE_CELL_WITHOUT_HEATMAP_VIEWS = {
+  obsSets: { x: 10, y: 6, w: 2, h: 6 },
+  obsSetSizes: { x: 8, y: 1, w: 4, h: 6 },
+  scatterplot: { x: 0, y: 0, w: 8, h: 12 },
+  featureList: { x: 8, y: 6, w: 2, h: 6 }
+};
+const SPATIAL_TRANSCRIPTOMICS_VIEWS = {
+  scatterplot: { x: 0, y: 0, w: 3, h: 4 },
+  spatial: { x: 3, y: 0, w: 5, h: 4 },
+  obsSets: { x: 8, y: 0, w: 4, h: 2 },
+  featureList: { x: 8, y: 0, w: 4, h: 2 },
+  heatmap: { x: 0, y: 4, w: 6, h: 4 },
+  obsSetFeatureValueDistribution: { x: 6, y: 4, w: 6, h: 4 }
+};
+const SPATIAL_TRANSCRIPTOMICS_WITH_HSITOLOGY_VIEWS = {
+  spatial: { x: 0, y: 0, w: 6, h: 6 },
+  heatmap: { x: 0, y: 6, w: 8, h: 6 },
+  layerController: { x: 8, y: 6, w: 4, h: 6 },
+  obsSets: { x: 9, y: 0, w: 3, h: 6 },
+  featureList: { x: 6, y: 0, w: 3, h: 6 }
+};
+const IMAGE_VIEWS = {
+  spatial: { x: 0, y: 0, w: 8, h: 12 },
+  layerController: { x: 8, y: 0, w: 4, h: 7 },
+  description: { x: 8, y: 9, w: 4, h: 5 }
+};
+const NO_HINTS_CONFIG = {
+  views: {},
+  coordinationValues: {}
+};
+const HINTS_CONFIG = {
+  "No hints are available. Generate config with no hints.": NO_HINTS_CONFIG,
+  Basic: NO_HINTS_CONFIG,
+  "Transcriptomics / scRNA-seq (with heatmap)": {
+    views: SINGLE_CELL_WITH_HEATMAP_VIEWS
+  },
+  "Transcriptomics / scRNA-seq (without heatmap)": {
+    views: SINGLE_CELL_WITHOUT_HEATMAP_VIEWS
+  },
+  "Spatial transcriptomics (with polygon cell segmentations)": {
+    views: SPATIAL_TRANSCRIPTOMICS_VIEWS
+  },
+  "Chromatin accessibility / scATAC-seq (with heatmap)": {
+    views: SINGLE_CELL_WITH_HEATMAP_VIEWS,
+    coordinationValues: {
+      featureType: "peak"
+    }
+  },
+  "Chromatin accessibility / scATAC-seq (without heatmap)": {
+    views: SINGLE_CELL_WITHOUT_HEATMAP_VIEWS,
+    coordinationValues: {
+      featureType: "peak"
+    }
+  },
+  "Spatial transcriptomics (with histology image and polygon cell segmentations)": {
+    views: SPATIAL_TRANSCRIPTOMICS_WITH_HSITOLOGY_VIEWS,
+    coordinationSpaceRequired: true
+  },
+  Image: {
+    views: IMAGE_VIEWS
+  }
+};
+const HINT_TYPE_TO_FILE_TYPE_MAP = {
+  "AnnData-Zarr": [
+    "Basic",
+    "Transcriptomics / scRNA-seq (with heatmap)",
+    "Transcriptomics / scRNA-seq (without heatmap)",
+    "Spatial transcriptomics (with polygon cell segmentations)",
+    "Chromatin accessibility / scATAC-seq (with heatmap)",
+    "Chromatin accessibility / scATAC-seq (without heatmap)"
+  ],
+  "OME-TIFF": [
+    "Basic",
+    "Image"
+  ],
+  "AnnData-Zarr,OME-TIFF": [
+    "Basic",
+    "Spatial transcriptomics (with histology image and polygon cell segmentations)"
+  ]
+};
+const filterViews = (hintsConfig, possibleViews) => {
+  const requiredViews = Object.keys(hintsConfig.views);
+  if (requiredViews.length === 0) {
+    return possibleViews;
+  }
+  const resultViews = [];
+  requiredViews.forEach((requiredView) => {
+    const match = possibleViews.find((possibleView) => possibleView[0] === requiredView);
+    if (match)
+      resultViews.push(match);
+  });
+  if (resultViews.length === 0) {
+    throw new Error("No views found that are compatible with the supplied dataset URLs and hint.");
+  }
+  return resultViews;
+};
 class AbstractAutoConfig {
   async composeViewsConfig() {
     throw new Error("The composeViewsConfig() method has not been implemented.");
@@ -15599,12 +15918,11 @@ class OmeTiffAutoConfig extends AbstractAutoConfig {
     this.fileType = FileType$1.RASTER_JSON;
     this.fileName = fileUrl.split("/").at(-1);
   }
-  async composeViewsConfig() {
-    return [
-      ["description"],
-      ["spatial"],
-      ["layerController"]
-    ];
+  async composeViewsConfig(hintsConfig) {
+    return filterViews(
+      hintsConfig,
+      [["description"], ["spatial"], ["layerController"]]
+    );
   }
   async composeFileConfig() {
     return {
@@ -15633,13 +15951,11 @@ class OmeZarrAutoConfig extends AbstractAutoConfig {
     this.fileType = FileType$1.RASTER_OME_ZARR;
     this.fileName = fileUrl.split("/").at(-1);
   }
-  async composeViewsConfig() {
-    return [
-      ["description"],
-      ["spatial"],
-      ["layerController"],
-      ["status"]
-    ];
+  async composeViewsConfig(hintsConfig) {
+    return filterViews(
+      hintsConfig,
+      [["description"], ["spatial"], ["layerController"]]
+    );
   }
   async composeFileConfig() {
     return {
@@ -15658,6 +15974,7 @@ class AnndataZarrAutoConfig extends AbstractAutoConfig {
     this.metadataSummary = {};
   }
   async composeFileConfig() {
+    var _a;
     this.metadataSummary = await this.setMetadataSummary();
     const options = {
       obsEmbedding: [],
@@ -15684,8 +16001,10 @@ class AnndataZarrAutoConfig extends AbstractAutoConfig {
     });
     const supportedObsSetsKeys = [
       "cluster",
+      "clusters",
       "subcluster",
       "cell_type",
+      "celltype",
       "leiden",
       "louvain",
       "disease",
@@ -15710,6 +16029,15 @@ class AnndataZarrAutoConfig extends AbstractAutoConfig {
         }
       });
     });
+    options.obsSets = (_a = options.obsSets) == null ? void 0 : _a.map((obsSet) => {
+      if (obsSet.path.length === 1) {
+        return {
+          ...obsSet,
+          path: obsSet.path[0]
+        };
+      }
+      return obsSet;
+    });
     return {
       options,
       fileType: this.fileType,
@@ -15721,97 +16049,148 @@ class AnndataZarrAutoConfig extends AbstractAutoConfig {
       }
     };
   }
-  async composeViewsConfig() {
+  async composeViewsConfig(hintsConfig) {
     this.metadataSummary = await this.setMetadataSummary();
-    const views = [];
-    const hasCellSetData = this.metadataSummary.obs.filter((key) => key.toLowerCase().includes("cluster") || key.toLowerCase().includes("cell_type"));
+    const possibleViews = [];
+    const hasCellSetData = this.metadataSummary.obs.filter((key) => key.toLowerCase().includes("cluster") || key.toLowerCase().includes("cell_type") || key.toLowerCase().includes("celltype"));
     if (hasCellSetData.length > 0) {
-      views.push(["obsSets"]);
+      possibleViews.push(["obsSets"]);
     }
     this.metadataSummary.obsm.forEach((key) => {
       if (key.toLowerCase().includes("obsm/x_umap")) {
-        views.push(["scatterplot", { mapping: "UMAP" }]);
+        possibleViews.push(["scatterplot", { mapping: "UMAP" }]);
       }
       if (key.toLowerCase().includes("obsm/x_tsne")) {
-        views.push(["scatterplot", { mapping: "t-SNE" }]);
+        possibleViews.push(["scatterplot", { mapping: "t-SNE" }]);
       }
       if (key.toLowerCase().includes("obsm/x_pca")) {
-        views.push(["scatterplot", { mapping: "PCA" }]);
+        possibleViews.push(["scatterplot", { mapping: "PCA" }]);
       }
       if (key.toLowerCase().includes("obsm/x_segmentations")) {
-        views.push(["layerController"]);
+        possibleViews.push(["layerController"]);
       }
       if (key.toLowerCase().includes("obsm/x_spatial")) {
-        views.push(["spatial"]);
+        possibleViews.push(["spatial"]);
       }
     });
+    possibleViews.push(["obsSetSizes"]);
+    possibleViews.push(["obsSetFeatureValueDistribution"]);
     if (this.metadataSummary.X) {
-      views.push(["heatmap"]);
-      views.push(["featureList"]);
+      possibleViews.push(["heatmap"]);
+      possibleViews.push(["featureList"]);
     }
+    const views = filterViews(hintsConfig, possibleViews);
     return views;
   }
+  async setMetadataSummaryWithZmetadata(response) {
+    const metadataFile = await response.json();
+    if (!metadataFile.metadata) {
+      throw new Error("Could not generate config: .zmetadata file is not valid.");
+    }
+    const obsmKeys = Object.keys(metadataFile.metadata).filter((key) => key.startsWith("obsm/X_")).map((key) => key.split("/.zarray")[0]);
+    const obsKeysArr = Object.keys(metadataFile.metadata).filter((key) => key.startsWith("obs/")).map((key) => key.split("/.za")[0]);
+    function uniq(a) {
+      return a.sort().filter((item, pos, ary) => !pos || item !== ary[pos - 1]);
+    }
+    const obsKeys = uniq(obsKeysArr);
+    const X = Object.keys(metadataFile.metadata).filter((key) => key.startsWith("X"));
+    return {
+      // Array of keys in obsm that are found by the fetches above
+      obsm: obsmKeys,
+      // Array of keys in obs that are found by the fetches above
+      obs: obsKeys,
+      // Boolean indicating whether the X array was found by the fetches above
+      X: X.length > 0
+    };
+  }
+  async setMetadataSummaryWithoutZmetadata() {
+    const knownMetadataFileSuffixes = [
+      "/obsm/X_pca/.zarray",
+      "/obsm/X_umap/.zarray",
+      "/obsm/X_tsne/.zarray",
+      "/obsm/X_spatial/.zarray",
+      "/obsm/X_segmentations/.zarray",
+      "/obs/.zattrs",
+      "/X/.zarray",
+      "/X/data/.zarray"
+      // for https://s3.amazonaws.com/vitessce-data/0.0.33/main/human-lymph-node-10x-visium/human_lymph_node_10x_visium.h5ad.zarr
+    ];
+    const getObsmKey = (url) => {
+      const obsmKeyStartIndex = `${this.fileUrl}/`.length;
+      const obsmKeyEndIndex = url.length - "/.zarray".length;
+      return url.substring(obsmKeyStartIndex, obsmKeyEndIndex);
+    };
+    const promises = knownMetadataFileSuffixes.map((suffix) => fetch(`${this.fileUrl}${suffix}`));
+    const fetchResults = await Promise.all(promises);
+    const okFetchResults = fetchResults.filter((j) => j.ok);
+    const metadataSummary = {
+      // Array of keys in obsm that are found by the fetches above
+      obsm: [],
+      // Array of keys in obs that are found by the fetches above
+      obs: [],
+      // Boolean indicating whether the X array was found by the fetches above
+      X: false
+    };
+    const obsPromiseResult = okFetchResults.find(
+      (r) => r.url === `${this.fileUrl}/obs/.zattrs`
+    );
+    const isObsValid = (obsAttr) => Object.keys(obsAttr).includes("column-order") && Object.keys(obsAttr).includes("encoding-version") && Object.keys(obsAttr).includes("encoding-type") && obsAttr["encoding-type"] === "dataframe" && (obsAttr["encoding-version"] === "0.1.0" || obsAttr["encoding-version"] === "0.2.0");
+    if (obsPromiseResult) {
+      const obsAttrs = await obsPromiseResult.json();
+      if (isObsValid(obsAttrs)) {
+        obsAttrs["column-order"].forEach((key) => metadataSummary.obs.push(`obs/${key}`));
+      } else {
+        throw new Error("Could not generate config: /obs/.zattrs file is not valid.");
+      }
+    }
+    okFetchResults.forEach((r) => {
+      if (r.url.startsWith(`${this.fileUrl}/obsm`)) {
+        const obsmKey = getObsmKey(r.url);
+        if (obsmKey) {
+          metadataSummary.obsm.push(obsmKey);
+        }
+      } else if (r.url.startsWith(`${this.fileUrl}/X`)) {
+        metadataSummary.X = true;
+      }
+    });
+    return metadataSummary;
+  }
   async setMetadataSummary() {
     if (Object.keys(this.metadataSummary).length > 0) {
       return this.metadataSummary;
     }
-    const parseMetadataFile = (metadataFile) => {
-      if (!metadataFile.metadata) {
-        throw new Error("Could not generate config: .zmetadata file is not valid.");
-      }
-      const obsmKeys = Object.keys(metadataFile.metadata).filter((key) => key.startsWith("obsm/X_")).map((key) => key.split("/.zarray")[0]);
-      const obsKeysArr = Object.keys(metadataFile.metadata).filter((key) => key.startsWith("obs/")).map((key) => key.split("/.za")[0]);
-      function uniq(a) {
-        return a.sort().filter((item, pos, ary) => !pos || item !== ary[pos - 1]);
-      }
-      const obsKeys = uniq(obsKeysArr);
-      const X = Object.keys(metadataFile.metadata).filter((key) => key.startsWith("X"));
-      const out = {
-        obsm: obsmKeys,
-        obs: obsKeys,
-        X: X.length > 0
-      };
-      return out;
-    };
     const metadataExtension = ".zmetadata";
     const url = [this.fileUrl, metadataExtension].join("/");
     return fetch(url).then((response) => {
       if (response.ok) {
-        return response.json();
+        return this.setMetadataSummaryWithZmetadata(response);
       }
-      return Promise.reject(response);
-    }).then((responseJson) => parseMetadataFile(responseJson)).catch((error) => {
-      if (error.status === 404) {
-        const errorMssg = `Could not generate config. File ${metadataExtension} not found in supplied file URL. Check docs for more explanation.`;
-        return Promise.reject(new Error(errorMssg));
+      if (response.status === 404) {
+        return this.setMetadataSummaryWithoutZmetadata();
       }
-      return Promise.reject(error);
+      throw new Error(`Could not generate config: ${response.statusText}`);
+    }).catch((error) => {
+      throw new Error(`Could not generate config for URL ${this.fileUrl}: ${error}`);
     });
   }
 }
 const configClasses = [
   {
     extensions: [".ome.tif", ".ome.tiff", ".ome.tf2", ".ome.tf8"],
-    class: OmeTiffAutoConfig
+    class: OmeTiffAutoConfig,
+    name: "OME-TIFF"
   },
   {
     extensions: [".h5ad.zarr", ".adata.zarr", ".anndata.zarr"],
-    class: AnndataZarrAutoConfig
+    class: AnndataZarrAutoConfig,
+    name: "AnnData-Zarr"
   },
   {
     extensions: ["ome.zarr"],
-    class: OmeZarrAutoConfig
+    class: OmeZarrAutoConfig,
+    name: "OME-Zarr"
   }
 ];
-function getFileType(url) {
-  const match = configClasses.find((obj) => obj.extensions.filter(
-    (ext) => url.endsWith(ext)
-  ).length === 1);
-  if (!match) {
-    throw new Error(`Could not generate config for URL: ${url}. This file type is not supported.`);
-  }
-  return match.class;
-}
 function calculateCoordinates(viewsNumb) {
   const rows = Math.ceil(Math.sqrt(viewsNumb));
   const cols = Math.ceil(viewsNumb / rows);
@@ -15823,14 +16202,117 @@ function calculateCoordinates(viewsNumb) {
     const col = i % cols;
     const x = col * width;
     const y = row * height;
-    coords.push([x, y, width, height]);
+    coords.push([
+      Math.floor(x),
+      Math.floor(y),
+      // Ensure width/height is at least 1.
+      Math.max(1, Math.floor(width)),
+      Math.max(1, Math.floor(height))
+    ]);
   }
   return coords;
 }
-async function generateConfig(url, vc) {
+const spatialSegmentationLayerValue = {
+  radius: 65,
+  stroked: true,
+  visible: true,
+  opacity: 1
+};
+function insertCoordinationSpaceForSpatial(views, vc) {
+  const [
+    spatialSegmentationLayer,
+    spatialImageLayer,
+    spatialZoom,
+    spatialTargetX,
+    spatialTargetY
+  ] = vc.addCoordination(
+    CoordinationType$1.SPATIAL_SEGMENTATION_LAYER,
+    CoordinationType$1.SPATIAL_IMAGE_LAYER,
+    CoordinationType$1.SPATIAL_ZOOM,
+    CoordinationType$1.SPATIAL_TARGET_X,
+    CoordinationType$1.SPATIAL_TARGET_Y
+  );
+  spatialSegmentationLayer.setValue(spatialSegmentationLayerValue);
+  spatialImageLayer.setValue([
+    {
+      type: "raster",
+      index: 0,
+      colormap: null,
+      transparentColor: null,
+      opacity: 1,
+      domainType: "Min/Max",
+      channels: [
+        {
+          selection: {
+            c: 0
+          },
+          color: [
+            255,
+            0,
+            0
+          ],
+          visible: true,
+          slider: [
+            0,
+            255
+          ]
+        },
+        {
+          selection: {
+            c: 1
+          },
+          color: [
+            0,
+            255,
+            0
+          ],
+          visible: true,
+          slider: [
+            0,
+            255
+          ]
+        },
+        {
+          selection: {
+            c: 2
+          },
+          color: [
+            0,
+            0,
+            255
+          ],
+          visible: true,
+          slider: [
+            0,
+            255
+          ]
+        }
+      ]
+    }
+  ]);
+  views.forEach((view) => {
+    if (view.view.component === "spatial" || view.view.component === "layerController") {
+      view.useCoordination(spatialImageLayer);
+      view.useCoordination(spatialSegmentationLayer);
+      view.useCoordination(spatialZoom);
+      view.useCoordination(spatialTargetX);
+      view.useCoordination(spatialTargetY);
+    }
+  });
+}
+function getFileType(url) {
+  const match = configClasses.find((obj) => obj.extensions.filter(
+    (ext) => url.endsWith(ext)
+  ).length === 1);
+  if (!match) {
+    throw new Error("One or more of the URLs provided point to unsupported file types.");
+  }
+  return match;
+}
+async function generateViewDefinition(url, vc, dataset, hintsConfig) {
   let ConfigClassName;
   try {
-    ConfigClassName = getFileType(url);
+    ConfigClassName = getFileType(url).class;
   } catch (err) {
     return Promise.reject(err);
   }
@@ -15839,12 +16321,12 @@ async function generateConfig(url, vc) {
   let viewsConfig;
   try {
     fileConfig = await configInstance.composeFileConfig();
-    viewsConfig = await configInstance.composeViewsConfig();
+    viewsConfig = await configInstance.composeViewsConfig(hintsConfig);
   } catch (error) {
     console.error(error);
     return Promise.reject(error);
   }
-  const dataset = vc.addDataset(configInstance.fileName).addFile(fileConfig);
+  dataset.addFile(fileConfig);
   let layerControllerView = false;
   let spatialView = false;
   const views = [];
@@ -15856,7 +16338,7 @@ async function generateConfig(url, vc) {
     if (v[0] === "spatial") {
       spatialView = view;
     }
-    if (v[0] === "layerController" && configInstance instanceof OmeTiffAutoConfig) {
+    if (v[0] === "layerController") {
       view.setProps({
         disable3d: [],
         disableChannelsIfRgbDetected: true
@@ -15868,47 +16350,71 @@ async function generateConfig(url, vc) {
     views.push(view);
   });
   if (layerControllerView && spatialView && configInstance instanceof AnndataZarrAutoConfig) {
-    const spatialSegmentationLayerValue = {
-      opacity: 1,
-      radius: 0,
-      visible: true,
-      stroked: false
-    };
     vc.linkViews(
       [spatialView, layerControllerView],
       [
-        CoordinationType$1.SPATIAL_ZOOM,
-        CoordinationType$1.SPATIAL_TARGET_X,
-        CoordinationType$1.SPATIAL_TARGET_Y,
         CoordinationType$1.SPATIAL_SEGMENTATION_LAYER
       ],
-      [-5.5, 16e3, 2e4, spatialSegmentationLayerValue]
+      [spatialSegmentationLayerValue]
     );
   }
   return views;
 }
-async function generateConfigs(fileUrls) {
+function getHintOptions(fileUrls) {
+  const fileTypes = {};
+  fileUrls.forEach((url) => {
+    const match = getFileType(url);
+    if (match.name === "OME-Zarr") {
+      fileTypes["OME-TIFF"] = true;
+    } else {
+      fileTypes[match.name] = true;
+    }
+  });
+  const datasetType = Object.keys(fileTypes).sort().join(",");
+  return (HINT_TYPE_TO_FILE_TYPE_MAP == null ? void 0 : HINT_TYPE_TO_FILE_TYPE_MAP[datasetType]) || [];
+}
+async function generateConfig(fileUrls, hintTitle = null) {
+  var _a;
   const vc = new VitessceConfig({
     schemaVersion: "1.0.15",
     name: "An automatically generated config. Adjust values and add layout components if needed.",
     description: "Populate with text relevant to this visualisation."
   });
   const allViews = [];
+  const dataset = vc.addDataset("An automatically generated view config for dataset. Adjust values and add layout components if needed.");
+  const hintsConfig = !hintTitle ? { views: {} } : HINTS_CONFIG == null ? void 0 : HINTS_CONFIG[hintTitle];
+  if (!hintsConfig) {
+    throw new Error(`Hints config not found for the supplied hint: ${hintTitle}.`);
+  }
+  const useHints = ((_a = Object.keys(hintsConfig == null ? void 0 : hintsConfig.views)) == null ? void 0 : _a.length) > 0;
   fileUrls.forEach((url) => {
-    allViews.push(generateConfig(url, vc));
+    allViews.push(generateViewDefinition(url, vc, dataset, hintsConfig));
   });
   return Promise.all(allViews).then((views) => {
     const flattenedViews = views.flat();
-    const coord = calculateCoordinates(flattenedViews.length);
-    for (let i = 0; i < flattenedViews.length; i++) {
-      flattenedViews[i].setXYWH(...coord[i]);
+    if (hintsConfig == null ? void 0 : hintsConfig.coordinationSpaceRequired) {
+      insertCoordinationSpaceForSpatial(flattenedViews, vc);
+    }
+    if (!useHints) {
+      const coord = calculateCoordinates(flattenedViews.length);
+      for (let i = 0; i < flattenedViews.length; i++) {
+        flattenedViews[i].setXYWH(...coord[i]);
+      }
+    } else {
+      flattenedViews.forEach((vitessceConfigView) => {
+        const coordinates = Object.values(hintsConfig.views[vitessceConfigView.view.component]);
+        vitessceConfigView.setXYWH(...coordinates);
+      });
     }
     return vc.toJSON();
   });
 }
 export {
+  HINTS_CONFIG,
+  HINT_TYPE_TO_FILE_TYPE_MAP,
   VitessceConfig,
-  generateConfigs,
+  generateConfig,
+  getHintOptions,
   hconcat,
   vconcat
 };