dbf-mirador 4.2.3

package/src/state/selectors/ranges.js

@@ -0,0 +1,147 @@
+import { createSelector } from 'reselect';
+import union from 'lodash/union';
+import without from 'lodash/without';
+import { Utils } from 'manifesto.js';
+import { getVisibleCanvasIds } from './canvases';
+import { getCompanionWindow } from './companionWindows';
+import { getSequenceTreeStructure } from './sequences';
+
+/** */
+function rangeContainsCanvasId(range, canvasId) {
+  const canvasIds = range.getCanvasIds();
+  for (let i = 0; i < canvasIds.length; i += 1) {
+    if (Utils.normalisedUrlsMatch(canvasIds[i], canvasId)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/** */
+function getAllParentIds(node) {
+  if (node.parentNode === undefined) {
+    return [];
+  }
+  if (node.parentNode.parentNode === undefined) {
+    return [node.parentNode.id];
+  }
+  return [...getAllParentIds(node.parentNode), node.parentNode.id];
+}
+
+/** */
+function getVisibleNodeIdsInSubTree(nodes, canvasIds) {
+  return nodes.reduce((nodeIdAcc, node) => {
+    const result = [];
+    result.push(...nodeIdAcc);
+    const nodeContainsVisibleCanvas = canvasIds.reduce(
+      (acc, canvasId) => acc || rangeContainsCanvasId(node.data, canvasId),
+      false,
+    );
+    const subTreeVisibleNodeIds = node.nodes.length > 0 ? getVisibleNodeIdsInSubTree(node.nodes, canvasIds) : [];
+    result.push(...subTreeVisibleNodeIds);
+    if (nodeContainsVisibleCanvas || subTreeVisibleNodeIds.length > 0) {
+      result.push({
+        containsVisibleCanvas: nodeContainsVisibleCanvas,
+        descendantsContainVisibleCanvas: subTreeVisibleNodeIds.length > 0,
+        id: node.id,
+        leaf: node.nodes.length === 0,
+        parentIds: getAllParentIds(node),
+      });
+    }
+    return result;
+  }, []);
+}
+
+/** */
+const getVisibleLeafAndBranchNodeIds = createSelector([getSequenceTreeStructure, getVisibleCanvasIds], (tree, canvasIds) => {
+  if (canvasIds.length === 0 || !tree) return [];
+  return getVisibleNodeIdsInSubTree(tree.nodes, canvasIds);
+});
+
+/**
+ * Returns visible node ids.
+ * @param {object} state
+ * @param {object} props
+ * @param {string} props.windowId
+ * @returns {Array}
+ */
+export const getVisibleNodeIds = createSelector([getVisibleLeafAndBranchNodeIds], (visibleLeafAndBranchNodeIds) =>
+  visibleLeafAndBranchNodeIds.map((item) => item.id),
+);
+
+const getVisibleBranchNodeIds = createSelector([getVisibleLeafAndBranchNodeIds], (visibleLeafAndBranchNodeIds) =>
+  visibleLeafAndBranchNodeIds.reduce(
+    (acc, item) => (item.leaf || !item.descendantsContainVisibleCanvas ? acc : [...acc, item.id]),
+    [],
+  ),
+);
+
+const getCanvasContainingNodeIds = createSelector([getVisibleLeafAndBranchNodeIds], (visibleLeafAndBranchNodeIds) =>
+  visibleLeafAndBranchNodeIds.reduce((acc, item) => (item.containsVisibleCanvas ? [...acc, item] : acc), []),
+);
+
+/**
+ * Returns ids of manually exanded nodes.
+ * @param {object} state
+ * @param {object} props
+ * @param {string} props.companionWindowId
+ * @param expanded
+ * @returns {Array}
+ */
+export function getManuallyExpandedNodeIds(state, { companionWindowId }, expanded) {
+  const companionWindow = getCompanionWindow(state, { companionWindowId });
+  return companionWindow.tocNodes
+    ? Object.keys(companionWindow.tocNodes).reduce(
+        (acc, nodeId) => (companionWindow.tocNodes[nodeId].expanded === expanded ? [...acc, nodeId] : acc),
+        [],
+      )
+    : [];
+}
+
+/**
+ * Returns ids of exanded nodes.
+ * @param {object} state
+ * @param {object} props
+ * @param {string} props.companionWindowId
+ * @param {string} props.windowId
+ * @returns {Array}
+ */
+export function getExpandedNodeIds(state, { companionWindowId, windowId }) {
+  const visibleBranchNodeIds = getVisibleBranchNodeIds(state, { companionWindowId, windowId });
+  const manuallyExpandedNodeIds = getManuallyExpandedNodeIds(state, { companionWindowId }, true);
+  const manuallyClosedNodeIds = getManuallyExpandedNodeIds(state, { companionWindowId }, false);
+  return without(union(manuallyExpandedNodeIds, visibleBranchNodeIds), ...manuallyClosedNodeIds);
+}
+
+/**
+ * Returns id of node to scroll to.
+ * @param {object} state
+ * @param {object} props
+ * @param {string} props.companionWindowId
+ * @param {string} props.windowId
+ * @param {string} props.manifestid
+ * @returns {string}
+ */
+export function getNodeIdToScrollTo(state, { ...args }) {
+  const canvasContainingNodeIds = getCanvasContainingNodeIds(state, { ...args });
+  const collapsedNodeIds = getManuallyExpandedNodeIds(state, args, false);
+  if (canvasContainingNodeIds && canvasContainingNodeIds.length > 0) {
+    for (let i = 0; i < canvasContainingNodeIds[0].parentIds.length; i += 1) {
+      if (collapsedNodeIds.indexOf(canvasContainingNodeIds[0].parentIds[i]) !== -1) {
+        return canvasContainingNodeIds[0].parentIds[i];
+      }
+    }
+    return canvasContainingNodeIds[0].id;
+  }
+  return null;
+}
+
+/**
+ * Returns the default sidebar variant depending on whether or not ranges exist.
+ * @param {object} state
+ * @param {string}
+ * @returns {string}
+ */
+export const getDefaultSidebarVariant = createSelector([getSequenceTreeStructure], (tree) =>
+  tree && tree.nodes && tree.nodes.length > 0 ? 'tableOfContents' : 'item',
+);

package/src/state/selectors/searches.js

@@ -0,0 +1,249 @@
+import { createSelector } from 'reselect';
+import { PropertyValue } from 'manifesto.js';
+import AnnotationList from '../../lib/AnnotationList';
+import { getCanvas, getCanvases } from './canvases';
+import { getWindow } from './getters';
+import { getManifestLocale } from './manifests';
+import { miradorSlice, EMPTY_ARRAY, EMPTY_OBJECT } from './utils';
+
+/**
+ *  Get searches from state.
+ */
+const getSearches = (state) => miradorSlice(state).searches;
+
+/**
+ * Returns the search result for a specific window.
+ * @param {object} state
+ * @param {string} windowId
+ * @returns {object}
+ */
+export const getSearchForWindow = createSelector([(state, { windowId }) => windowId, getSearches], (windowId, searches) => {
+  if (!windowId || !searches) return EMPTY_OBJECT;
+
+  return searches[windowId];
+});
+
+/**
+ * Returns the search result for a specific companion window.
+ * @param {object} state
+ * @param {string} companionWindowId
+ * @returns {object|undefined}
+ */
+const getSearchForCompanionWindow = createSelector(
+  [getSearchForWindow, (state, { companionWindowId }) => companionWindowId],
+  (results, companionWindowId) => {
+    if (!results || !companionWindowId) return undefined;
+    return results[companionWindowId];
+  },
+);
+
+/**
+ * Returns an array of search responses for a specific companion window.
+ * @param {object} state
+ * @returns {Array}
+ */
+const getSearchResponsesForCompanionWindow = createSelector([getSearchForCompanionWindow], (results) => {
+  if (!results) return EMPTY_ARRAY;
+  return Object.values(results.data);
+});
+
+/**
+ * Returns the search query for a specific companion window.
+ * @param {object} state
+ * @param {string} windowId
+ * @returns {string|undefined}
+ */
+export const getSearchQuery = createSelector([getSearchForCompanionWindow], (results) => results && results.query);
+
+/**
+ * Returns if search response for a companion window is fetching.
+ * @param {object} state
+ * @returns {boolean}
+ */
+export const getSearchIsFetching = createSelector([getSearchResponsesForCompanionWindow], (results) =>
+  results.some((result) => result.isFetching),
+);
+
+/**
+ * Returns the total number of search results for a companion window.
+ * @param {object} state
+ * @param {string} windowId
+ * @returns {number|undefined}
+ */
+export const getSearchNumTotal = createSelector([getSearchForCompanionWindow], (results) => {
+  if (!results || !results.data) return undefined;
+
+  const resultWithWithin = Object.values(results.data).find((result) => !result.isFetching && result.json && result.json.within);
+  return resultWithWithin?.json?.within?.total;
+});
+
+/**
+ * Returns the Id of the next search.
+ * @param {object} state
+ * @param {string} windowId
+ * @returns {number|undefined}
+ */
+export const getNextSearchId = createSelector([getSearchForCompanionWindow], (results) => {
+  if (!results || !results.data) return undefined;
+
+  const resultWithAnUnresolvedNext = Object.values(results.data).find(
+    (result) => !result.isFetching && result.json && result.json.next && !results.data[result.json.next],
+  );
+
+  return resultWithAnUnresolvedNext && resultWithAnUnresolvedNext.json && resultWithAnUnresolvedNext.json.next;
+});
+
+const getSearchHitsForCompanionWindow = createSelector([getSearchResponsesForCompanionWindow], (results) =>
+  results.flatMap((result) => {
+    if (!result || !result.json || result.isFetching || !result.json.hits) return EMPTY_ARRAY;
+
+    return result.json.hits;
+  }),
+);
+
+export const getSearchAnnotationsForCompanionWindow = createSelector(
+  [getSearchResponsesForCompanionWindow],
+  (results) => results && searchResultsToAnnotation(results),
+);
+
+/**
+ * Returns sorted search hits based on canvas order.
+ * @param {object} state
+ * @param {string} manifestId
+ * @returns {Array}
+ */
+export const getSortedSearchHitsForCompanionWindow = createSelector(
+  [getSearchHitsForCompanionWindow, getCanvases, getSearchAnnotationsForCompanionWindow],
+  (searchHits, canvases, annotation) => {
+    if (!canvases || canvases.length === 0) return EMPTY_ARRAY;
+    if (!searchHits || searchHits.length === 0) return EMPTY_ARRAY;
+    const canvasIds = canvases.map((canvas) => canvas.id);
+
+    return [].concat(searchHits).sort((a, b) => {
+      const hitA = annotation.resources.find((r) => r.id === a.annotations[0]);
+      const hitB = annotation.resources.find((r) => r.id === b.annotations[0]);
+      return canvasIds.indexOf(hitA.targetId) - canvasIds.indexOf(hitB.targetId);
+    });
+  },
+);
+
+/** convert search results to an annotation */
+const searchResultsToAnnotation = (results) => {
+  const annotations = results
+    .map((result) => {
+      if (!result || !result.json || result.isFetching || !result.json.resources) return undefined;
+      const anno = new AnnotationList(result.json);
+      return {
+        id: anno.id,
+        resources: anno.resources,
+      };
+    })
+    .filter(Boolean);
+
+  return {
+    id: (annotations.find((a) => a.id) || {}).id,
+    resources: annotations.flatMap((a) => a.resources),
+  };
+};
+
+/**
+ * Sorts search annotations based on canvas order.
+ * @returns {Array}
+ */
+export function sortSearchAnnotationsByCanvasOrder(searchAnnotations, canvases) {
+  if (!searchAnnotations || !searchAnnotations.resources || searchAnnotations.length === 0) return EMPTY_ARRAY;
+  if (!canvases || canvases.length === 0) return EMPTY_ARRAY;
+  const canvasIds = canvases.map((canvas) => canvas.id);
+
+  return []
+    .concat(searchAnnotations.resources)
+    .sort((annoA, annoB) => canvasIds.indexOf(annoA.targetId) - canvasIds.indexOf(annoB.targetId));
+}
+
+/**
+ * Returns sorted search annotations for companion window.
+ * @param {object} state
+ * @param {string} companionWindowId
+ * @returns {Array}
+ */
+export const getSortedSearchAnnotationsForCompanionWindow = createSelector(
+  [getSearchAnnotationsForCompanionWindow, getCanvases],
+  (searchAnnotations, canvases) => sortSearchAnnotationsByCanvasOrder(searchAnnotations, canvases),
+);
+
+/**
+ * Returns sorted search annotations for window.
+ * @param {object} state
+ * @param {string} windowId
+ * @returns {Array}
+ */
+export const getSearchAnnotationsForWindow = createSelector([getSearchForWindow], (results) => {
+  if (!results) return EMPTY_ARRAY;
+  const data = Object.values(results).map((r) => Object.values(r.data));
+
+  return data.map((d) => searchResultsToAnnotation(d)).filter((a) => a.resources.length > 0);
+});
+
+/**
+ * Returns ids of selected content search annotations.
+ * @param {object} state
+ * @param {string} windowId
+ * @returns {Array}
+ */
+export const getSelectedContentSearchAnnotationIds = createSelector(
+  [getWindow, getSearchForCompanionWindow],
+  (window, search) => (search && search.selectedContentSearchAnnotationIds) || [],
+);
+
+/**
+ * Returns resource annotations for search hit.
+ * @param {object} state
+ * @param {string} windowId
+ * @returns {Array}
+ */
+export const getResourceAnnotationForSearchHit = createSelector(
+  [getSearchAnnotationsForCompanionWindow, (state, { annotationUri }) => annotationUri],
+  (annotation, annotationUri) => annotation.resources.find((r) => r.id === annotationUri),
+);
+
+/**
+ * Returns annotation label.
+ * @param {object} state
+ * @param {string} windowId
+ * @returns {Array}
+ */
+export const getResourceAnnotationLabel = createSelector(
+  [getResourceAnnotationForSearchHit, getManifestLocale],
+  (resourceAnnotation, locale) => {
+    if (!(resourceAnnotation && resourceAnnotation.resource && resourceAnnotation.resource.label)) return EMPTY_ARRAY;
+
+    return PropertyValue.parse(resourceAnnotation.resource.label).getValues(locale);
+  },
+);
+
+const getAnnotationById = createSelector(
+  [getSearchAnnotationsForWindow, (state, { annotationId }) => annotationId],
+  (annotations, annotationId) => {
+    const resourceAnnotations = annotations.flatMap((a) => a.resources);
+    return resourceAnnotations.find((r) => r.id === annotationId);
+  },
+);
+
+/**
+ * Returns annotation label.
+ * @param {object} state
+ * @param {string} windowId
+ * @returns {Array}
+ */
+export const getCanvasForAnnotation = createSelector(
+  [
+    getAnnotationById,
+    (state, { windowId }) =>
+      (canvasId) =>
+        getCanvas(state, { canvasId, windowId }),
+  ],
+  (annotation, getCanvasById) => {
+    const canvasId = annotation && annotation.targetId;
+    return canvasId && getCanvasById(canvasId);
+  },
+);

package/src/state/selectors/sequences.js

@@ -0,0 +1,134 @@
+import { createSelector } from 'reselect';
+import { TreeNode } from 'manifesto.js';
+import { getManifestoInstance } from './manifests';
+import { getWindow } from './getters';
+
+/**
+ * Returns the sequences for a given windowId
+ * @param {object} state
+ * @param {object} props
+ * @param {string} props.windowId
+ * @returns {Array}
+ */
+export const getSequences = createSelector([getManifestoInstance], (manifest) => {
+  if (!manifest || !manifest.getTopRanges) return null;
+
+  const topRangesOrRoot = manifest.getTopRanges();
+  const v2TopRanges = topRangesOrRoot.filter((r) => r.getProperty('viewingHint') === 'top');
+  let v3RangeSequences = [];
+
+  if (v2TopRanges.length === 0 && topRangesOrRoot.length === 1) {
+    v3RangeSequences = topRangesOrRoot[0].getRanges().filter((r) => r.getBehavior() === 'sequence');
+  }
+
+  const sequences = [].concat(
+    // v2: multi-sequence manifests, or v3: items
+    manifest.getSequences(),
+    // v3: all top-level ranges with behavior=sequence
+    v3RangeSequences,
+  );
+
+  return sequences;
+});
+
+/**
+ * Returns the sequence for a given windowId
+ * @param {object} state
+ * @param {object} props
+ * @param {string} props.windowId
+ * @returns {Array}
+ */
+export const getSequence = createSelector(
+  [getSequences, getWindow, (state, { sequenceId }) => sequenceId],
+  (sequences, window, sequenceId) => {
+    if (!sequences) return null;
+
+    if (sequenceId || (window && window.sequenceId)) {
+      const currentSequence = sequences.find((s) => s.id === (sequenceId || window.sequenceId));
+
+      if (currentSequence) return currentSequence;
+    }
+
+    return sequences[0];
+  },
+);
+
+/**
+ * Return the canvas index for a certain window.
+ * @param {Object} state
+ * @param {string} windowId
+ * @returns {number}
+ */
+export const getCanvasIndex = createSelector(
+  [getWindow, getSequence],
+  (window, sequence) => ((sequence && window && window.canvasId && sequence.getCanvasById(window.canvasId)) || {}).index || 0,
+);
+
+/**
+ * Returns the viewing hint for the first sequence in the manifest or the manifest.
+ * @param {object} state
+ * @param {object} props
+ * @param {string} props.manifestId
+ * @param {string} props.windowId
+ * @returns {number}
+ */
+export const getSequenceViewingHint = createSelector([getSequence, getManifestoInstance], (sequence, manifest) => {
+  if (!manifest) return null;
+  const viewingHint = (sequence && sequence.getViewingHint()) || manifest.getViewingHint();
+  if (viewingHint) return viewingHint;
+  return null;
+});
+
+/**
+ * @param {object} state
+ * @param {string} windowId
+ * @return {string|null}
+ */
+export const getSequenceViewingDirection = createSelector(
+  [getWindow, getSequence, getManifestoInstance],
+  (window, sequence, manifest) => {
+    const viewingDirection =
+      (window && window.viewingDirection) ||
+      (sequence && sequence.getViewingDirection()) ||
+      (manifest && manifest.getViewingDirection());
+    if (viewingDirection) return viewingDirection;
+    return null;
+  },
+);
+
+/**
+ * Returns the behaviors viewing hint for the manifest
+ * @param {Object} state
+ * @param {Object} props
+ * @param {string} props.manifestId
+ * @param {string} props.windowId
+ * @return {number}
+ */
+export const getSequenceBehaviors = createSelector([getSequence, getManifestoInstance], (sequence, manifest) => {
+  if (!manifest || !sequence) return [];
+  const sequenceBehaviors = sequence && sequence.getProperty('behavior');
+
+  if (sequenceBehaviors) {
+    if (Array.isArray(sequenceBehaviors)) return sequenceBehaviors;
+    return [sequenceBehaviors];
+  }
+
+  const behaviors = manifest.getProperty('behavior');
+
+  if (!behaviors) return [];
+  if (Array.isArray(behaviors)) return behaviors;
+  return [behaviors];
+});
+
+/**
+ * Retruns a sequence tree structure.
+ * @param {object} state
+ * @param {object} props
+ * @param {string} props.windowId
+ * @returns {object}
+ */
+export const getSequenceTreeStructure = createSelector([getSequence, getManifestoInstance], (sequence, manifest) => {
+  if (sequence && sequence.getProperty('type') && sequence.isRange()) return sequence.getTree(new TreeNode('root'));
+
+  return manifest && manifest.getDefaultTree();
+});

package/src/state/selectors/thumbnails.js

@@ -0,0 +1,28 @@
+import { createSelector } from 'reselect';
+
+import { getThumbnailsConfig } from './config';
+import { getMiradorCanvasWrapper, getMiradorManifestWrapper } from './wrappers';
+
+import { ThumbnailFactory } from '../../lib/ThumbnailFactory';
+
+/** memoize thumbnail opts for selector */
+export const getIiifThumbnailOpts = createSelector(
+  [getThumbnailsConfig, (state, maxHeight, maxWidth) => maxHeight, (state, maxHeight, maxWidth) => maxWidth],
+  (thumbnails, maxHeight, maxWidth) => ({
+    maxHeight,
+    maxWidth,
+    preferredFormats: thumbnails.preferredFormats,
+  }),
+);
+
+/**
+ *  Instantiate a thumbnail factory.
+ * @param {object} state
+ * @param {integer} maxHeight
+ * @param {integer} maxWidth
+ * @return {object}
+ */
+export const getThumbnailFactory = createSelector(
+  [getIiifThumbnailOpts, getMiradorCanvasWrapper, getMiradorManifestWrapper],
+  (iiifOpts, getMiradorCanvas, getMiradorManifest) => new ThumbnailFactory(iiifOpts, { getMiradorCanvas, getMiradorManifest }),
+);

package/src/state/selectors/utils.js

@@ -0,0 +1,18 @@
+import settings from '../../config/settings';
+
+/**
+ * Returns Mirador's portion of the global Redux state.
+ * If settings.state.slice is set (e.g. 'mirador'), Mirador's state is read from state[slice],
+ * allowing Mirador to coexist in a shared Redux store.
+ * Otherwise, Mirador is assumed to own the entire Redux state.
+ * @param {object} state
+ * @returns {object}
+ */
+export function miradorSlice(state) {
+  if (settings.state.slice) return state[settings.state.slice];
+
+  return state;
+}
+
+export const EMPTY_ARRAY = Object.freeze([]);
+export const EMPTY_OBJECT = Object.freeze({});

package/src/state/selectors/viewer.js

@@ -0,0 +1,19 @@
+import { createSelector } from 'reselect';
+import CanvasWorld from '../../lib/CanvasWorld';
+
+import { getVisibleCanvases } from './canvases';
+import { getLayersForVisibleCanvases } from './layers';
+import { getSequenceViewingDirection } from './sequences';
+import { getMiradorCanvasWrapper } from './wrappers';
+
+/**
+ *  Instantiate a manifesto instance.
+ * @param {object} state
+ * @param {string} windowId
+ * @return {object}
+ */
+export const getCurrentCanvasWorld = createSelector(
+  [getVisibleCanvases, getLayersForVisibleCanvases, getSequenceViewingDirection, getMiradorCanvasWrapper],
+  (canvases, layers, viewingDirection, getMiradorCanvas) =>
+    new CanvasWorld(canvases.map(getMiradorCanvas), layers, viewingDirection),
+);

package/src/state/selectors/windows.js

@@ -0,0 +1,98 @@
+import { createSelector } from 'reselect';
+import { getManifestTitle } from './manifests';
+import { getConfig } from './config';
+import { getWindows, getWindow, getWindowIds } from './getters';
+import { getWorkspaceType } from './workspace';
+import { getSequenceViewingHint, getSequenceBehaviors } from './sequences';
+
+/**
+ * Returns the window configuration based.
+ * @param {object} state
+ * @param {string} windowId
+ * @returns {object}
+ */
+export const getWindowConfig = createSelector([getConfig, getWindow], ({ window: defaultConfig }, windowConfig = {}) => ({
+  ...defaultConfig,
+  ...windowConfig,
+}));
+
+/**
+ * Returns the manifest titles for all open windows.
+ * @param {object} state
+ * @returns {object}
+ */
+export function getWindowTitles(state) {
+  const result = {};
+
+  Object.keys(getWindows(state)).forEach((windowId) => {
+    result[windowId] = getManifestTitle(state, { windowId });
+  });
+
+  return result;
+}
+
+/**
+ * Returns an array containing the maximized windowIds.
+ * @param {object} state
+ * @return {Array}
+ */
+export const getMaximizedWindowsIds = createSelector([getWindows], (windows) =>
+  Object.values(windows)
+    .filter((window) => window.maximized === true)
+    .map((window) => window.id),
+);
+
+/**
+ * Returns type of view in a certain window.
+ * @param {object} state
+ * @param {object} props
+ * @param {string} props.manifestId
+ * @param {string} props.windowId
+ * @param {string}
+ */
+export const getWindowViewType = createSelector(
+  [getWindow, getWindowConfig, getSequenceViewingHint, getSequenceBehaviors],
+  (window, { views = [], defaultView }, manifestViewingHint, manifestBehaviors) => {
+    if (window && window.view) return window.view;
+
+    const config = (views || []).find(
+      (view) => view.behaviors && view.behaviors.some((b) => manifestViewingHint === b || manifestBehaviors.includes(b)),
+    );
+
+    return (config && config.key) || defaultView;
+  },
+);
+
+/**
+ * Returns the window view type for a given window.
+ * @param {object} state
+ * @param {string} windowId
+ * @returns {string} 'single' | 'book' | 'scroll' | 'gallery'
+ */
+export const getAllowedWindowViewTypes = createSelector(
+  [getSequenceViewingHint, getSequenceBehaviors, getWindowConfig],
+  (manifestViewingHint, manifestBehaviors, { views = [], defaultView }) =>
+    (views || []).reduce((allowedViews, view) => {
+      if (
+        view.key === defaultView ||
+        !view.behaviors ||
+        view.behaviors.some((b) => manifestViewingHint === b || manifestBehaviors.includes(b))
+      )
+        allowedViews.push(view.key);
+      return allowedViews;
+    }, []),
+);
+
+/**
+ * Return the draggability of a window.
+ * @param {object} state
+ * @param {object} props
+ * @returns {boolean}
+ */
+export const getWindowDraggability = createSelector(
+  [getWorkspaceType, getWindow, (state) => getWindowIds(state).length > 1],
+  (workspaceType, window, manyWindows) => {
+    if (workspaceType === 'elastic') return true;
+    return manyWindows && window && window.maximized === false;
+  },
+);