dbf-mirador 4.2.3

package/src/containers/ThumbnailCanvasGrouping.js

@@ -0,0 +1,29 @@
+import { compose } from 'redux';
+import { connect } from 'react-redux';
+import { withPlugins } from '../extend/withPlugins';
+import * as actions from '../state/actions';
+import { getCurrentCanvas, getConfig } from '../state/selectors';
+import { ThumbnailCanvasGrouping } from '../components/ThumbnailCanvasGrouping';
+
+/**
+ * mapDispatchToProps - used to hook up connect to action creators
+ * @memberof ThumbnailCanvasGrouping
+ * @private
+ */
+const mapDispatchToProps = (dispatch, { windowId }) => ({
+  setCanvas: (...args) => dispatch(actions.setCanvas(windowId, ...args)),
+});
+
+/**
+ * mapStateToProps - used to hook up state to props
+ * @memberof ThumbnailCanvasGrouping
+ * @private
+ */
+const mapStateToProps = (state, { windowId }) => ({
+  currentCanvasId: (getCurrentCanvas(state, { windowId }) || {}).id,
+  showThumbnailLabels: getConfig(state).thumbnailNavigation.showThumbnailLabels,
+});
+
+const enhance = compose(connect(mapStateToProps, mapDispatchToProps), withPlugins('ThumbnailCanvasGrouping'));
+
+export default enhance(ThumbnailCanvasGrouping);

package/src/containers/ThumbnailNavigation.js

@@ -0,0 +1,48 @@
+import { compose } from 'redux';
+import { connect } from 'react-redux';
+import { withPlugins } from '../extend/withPlugins';
+import * as actions from '../state/actions';
+import { ThumbnailNavigation } from '../components/ThumbnailNavigation';
+import {
+  getCompanionWindow,
+  getWindow,
+  getNextCanvasGrouping,
+  getPreviousCanvasGrouping,
+  getCanvasGroupings,
+  getCanvasIndex,
+  getWindowViewType,
+  getSequenceViewingDirection,
+  getConfig,
+} from '../state/selectors';
+
+/**
+ * mapStateToProps - used to hook up state to props
+ * @memberof ThumbnailNavigation
+ * @private
+ */
+const mapStateToProps = (state, { windowId }) => ({
+  canvasGroupings: getCanvasGroupings(state, { windowId }),
+  canvasIndex: getCanvasIndex(state, { windowId }),
+  hasNextCanvas: !!getNextCanvasGrouping(state, { windowId }),
+  hasPreviousCanvas: !!getPreviousCanvasGrouping(state, { windowId }),
+  position: getCompanionWindow(state, {
+    companionWindowId: getWindow(state, { windowId }).thumbnailNavigationId,
+  }).position,
+  thumbnailNavigation: getConfig(state).thumbnailNavigation,
+  view: getWindowViewType(state, { windowId }),
+  viewingDirection: getSequenceViewingDirection(state, { windowId }),
+});
+
+/**
+ * mapDispatchToProps - used to hook up connect to action creators
+ * @memberof ThumbnailNavigation
+ * @private
+ */
+const mapDispatchToProps = (dispatch, { windowId }) => ({
+  setNextCanvas: (...args) => dispatch(actions.setNextCanvas(windowId)),
+  setPreviousCanvas: (...args) => dispatch(actions.setPreviousCanvas(windowId)),
+});
+
+const enhance = compose(connect(mapStateToProps, mapDispatchToProps), withPlugins('ThumbnailNavigation'));
+
+export default enhance(ThumbnailNavigation);

package/src/containers/VideoViewer.js

@@ -0,0 +1,16 @@
+import { connect } from 'react-redux';
+import { compose } from 'redux';
+import { withPlugins } from '../extend/withPlugins';
+import { VideoViewer } from '../components/VideoViewer';
+import { getConfig, getVisibleCanvasCaptions, getVisibleCanvasVideoResources } from '../state/selectors';
+
+/** */
+const mapStateToProps = (state, { windowId }) => ({
+  captions: getVisibleCanvasCaptions(state, { windowId }) || [],
+  videoOptions: getConfig(state).videoOptions,
+  videoResources: getVisibleCanvasVideoResources(state, { windowId }) || [],
+});
+
+const enhance = compose(connect(mapStateToProps, null), withPlugins('VideoViewer'));
+
+export default enhance(VideoViewer);

package/src/containers/ViewerInfo.js

@@ -0,0 +1,30 @@
+import { compose } from 'redux';
+import { connect } from 'react-redux';
+import { withPlugins } from '../extend/withPlugins';
+import { ViewerInfo } from '../components/ViewerInfo';
+import { getCanvasLabel, getCanvases, getCanvasIndex, getCurrentCanvas } from '../state/selectors';
+
+/**
+ * mapStateToProps - to hook up connect
+ * @memberof Window
+ * @private
+ */
+const mapStateToProps = (state, props) => {
+  const { windowId } = props;
+  const canvases = getCanvases(state, { windowId });
+  const canvasIndex = getCanvasIndex(state, { windowId });
+  const canvasId = (getCurrentCanvas(state, { windowId }) || {}).id;
+
+  return {
+    canvasCount: canvases.length,
+    canvasIndex,
+    canvasLabel: getCanvasLabel(state, {
+      canvasId,
+      windowId,
+    }),
+  };
+};
+
+const enhance = compose(connect(mapStateToProps, null), withPlugins('ViewerInfo'));
+
+export default enhance(ViewerInfo);

package/src/containers/ViewerNavigation.js

@@ -0,0 +1,31 @@
+import { compose } from 'redux';
+import { connect } from 'react-redux';
+import { withPlugins } from '../extend/withPlugins';
+import * as actions from '../state/actions';
+import { getSequenceViewingDirection, getNextCanvasGrouping, getPreviousCanvasGrouping } from '../state/selectors';
+import { ViewerNavigation } from '../components/ViewerNavigation';
+
+/** */
+const mapStateToProps = (state, { windowId }) => ({
+  hasNextCanvas: !!getNextCanvasGrouping(state, { windowId }),
+  hasPreviousCanvas: !!getPreviousCanvasGrouping(state, { windowId }),
+  viewingDirection: getSequenceViewingDirection(state, { windowId }),
+});
+
+/**
+ * mapDispatchToProps - used to hook up connect to action creators
+ * @memberof ManifestForm
+ * @private
+ */
+const mapDispatchToProps = (dispatch, { windowId }) => ({
+  setNextCanvas: (...args) => dispatch(actions.setNextCanvas(windowId)),
+  setPreviousCanvas: (...args) => dispatch(actions.setPreviousCanvas(windowId)),
+});
+
+const enhance = compose(
+  connect(mapStateToProps, mapDispatchToProps),
+  withPlugins('ViewerNavigation'),
+  // further HOC go here
+);
+
+export default enhance(ViewerNavigation);

package/src/containers/Window.js

@@ -0,0 +1,45 @@
+import { compose } from 'redux';
+import { connect } from 'react-redux';
+import { withPlugins } from '../extend/withPlugins';
+import * as actions from '../state/actions';
+import { Window } from '../components/Window';
+import {
+  getManifestStatus,
+  getManifestTitle,
+  getThumbnailNavigationPosition,
+  getWindow,
+  getWorkspaceType,
+  getWindowDraggability,
+  getWindowViewType,
+  getManifestError,
+} from '../state/selectors';
+
+/**
+ * mapStateToProps - used to hook up connect to action creators
+ * @memberof Window
+ * @private
+ */
+const mapStateToProps = (state, { windowId }) => ({
+  isFetching: getManifestStatus(state, { windowId }).isFetching,
+  label: getManifestTitle(state, { windowId }),
+  manifestError: getManifestError(state, { windowId }),
+  maximized: (getWindow(state, { windowId }) || {}).maximized,
+  sideBarOpen: (getWindow(state, { windowId }) || {}).sideBarOpen,
+  thumbnailNavigationPosition: getThumbnailNavigationPosition(state, { windowId }),
+  view: getWindowViewType(state, { windowId }),
+  windowDraggable: getWindowDraggability(state, { windowId }),
+  workspaceType: getWorkspaceType(state),
+});
+
+/**
+ * mapDispatchToProps - used to hook up connect to action creators
+ * @memberof ManifestListItem
+ * @private
+ */
+const mapDispatchToProps = (dispatch, { windowId }) => ({
+  focusWindow: () => dispatch(actions.focusWindow(windowId)),
+});
+
+const enhance = compose(connect(mapStateToProps, mapDispatchToProps), withPlugins('Window'));
+
+export default enhance(Window);

package/src/containers/WindowAuthenticationBar.js

@@ -0,0 +1,7 @@
+import { compose } from 'redux';
+import { withPlugins } from '../extend/withPlugins';
+import { WindowAuthenticationBar } from '../components/WindowAuthenticationBar';
+
+const enhance = compose(withPlugins('WindowAuthenticationBar'));
+
+export default enhance(WindowAuthenticationBar);

package/src/containers/WindowCanvasNavigationControls.js

@@ -0,0 +1,15 @@
+import { connect } from 'react-redux';
+import { compose } from 'redux';
+import { withPlugins } from '../extend/withPlugins';
+import { getShowZoomControlsConfig, getWorkspace } from '../state/selectors';
+import { WindowCanvasNavigationControls } from '../components/WindowCanvasNavigationControls';
+
+/** */
+const mapStateToProps = (state, { windowId }) => ({
+  showZoomControls: getShowZoomControlsConfig(state),
+  visible: getWorkspace(state).focusedWindowId === windowId,
+});
+
+const enhance = compose(connect(mapStateToProps), withPlugins('WindowCanvasNavigationControls'));
+
+export default enhance(WindowCanvasNavigationControls);

package/src/containers/WindowList.js

@@ -0,0 +1,30 @@
+import { connect } from 'react-redux';
+import { compose } from 'redux';
+import { withPlugins } from '../extend/withPlugins';
+import * as actions from '../state/actions';
+import { getFocusedWindowId, getWindowIds, getWindowTitles } from '../state/selectors';
+import { WindowList } from '../components/WindowList';
+
+/**
+ * mapDispatchToProps - used to hook up connect to action creators
+ * @memberof ManifestListItem
+ * @private
+ */
+const mapDispatchToProps = {
+  focusWindow: actions.focusWindow,
+};
+
+/**
+ * mapStateToProps - to hook up connect
+ * @memberof WorkspaceControlPanel
+ * @private
+ */
+const mapStateToProps = (state) => ({
+  focusedWindowId: getFocusedWindowId(state),
+  titles: getWindowTitles(state),
+  windowIds: getWindowIds(state),
+});
+
+const enhance = compose(connect(mapStateToProps, mapDispatchToProps), withPlugins('WindowList'));
+
+export default enhance(WindowList);

package/src/containers/WindowListButton.js

@@ -0,0 +1,15 @@
+import { compose } from 'redux';
+import { connect } from 'react-redux';
+import { withPlugins } from '../extend/withPlugins';
+import { getWindowIds, getWorkspace } from '../state/selectors';
+import { WindowListButton } from '../components/WindowListButton';
+
+/** */
+const mapStateToProps = (state) => ({
+  disabled: getWorkspace(state).isWorkspaceAddVisible,
+  windowCount: getWindowIds(state).length,
+});
+
+const enhance = compose(connect(mapStateToProps, null), withPlugins('WindowListButton'));
+
+export default enhance(WindowListButton);

package/src/containers/WindowSideBar.js

@@ -0,0 +1,20 @@
+import { connect } from 'react-redux';
+import { compose } from 'redux';
+import { withPlugins } from '../extend/withPlugins';
+import { WindowSideBar } from '../components/WindowSideBar';
+import { getThemeDirection, getWindow } from '../state/selectors';
+
+/**
+ * mapStateToProps - to hook up connect
+ * @memberof WindowSideBar
+ * @private
+ */
+const mapStateToProps = (state, { windowId }) => ({
+  direction: getThemeDirection(state),
+  sideBarOpen: (getWindow(state, { windowId }) || {}).sideBarOpen,
+  sideBarPanel: (getWindow(state, { windowId }) || {}).sideBarPanel,
+});
+
+const enhance = compose(connect(mapStateToProps, null), withPlugins('WindowSideBar'));
+
+export default enhance(WindowSideBar);

package/src/containers/WindowSideBarAnnotationsPanel.js

@@ -0,0 +1,23 @@
+import { compose } from 'redux';
+import { connect } from 'react-redux';
+import { withPlugins } from '../extend/withPlugins';
+import { getVisibleCanvasIds, getAnnotationResourcesByMotivation } from '../state/selectors';
+import { WindowSideBarAnnotationsPanel } from '../components/WindowSideBarAnnotationsPanel';
+
+/**
+ * mapStateToProps - to hook up connect
+ * @memberof WindowSideBarAnnotationsPanel
+ * @private
+ */
+const mapStateToProps = (state, { windowId }) => ({
+  annotationCount: getAnnotationResourcesByMotivation(state, { windowId }).length,
+  canvasIds: getVisibleCanvasIds(state, { windowId }),
+});
+
+const enhance = compose(
+  connect(mapStateToProps, null),
+  withPlugins('WindowSideBarAnnotationsPanel'),
+  // further HOC
+);
+
+export default enhance(WindowSideBarAnnotationsPanel);

package/src/containers/WindowSideBarButtons.js

@@ -0,0 +1,75 @@
+import { compose } from 'redux';
+import { connect } from 'react-redux';
+import { withPlugins } from '../extend/withPlugins';
+import * as actions from '../state/actions';
+import MiradorCanvas from '../lib/MiradorCanvas';
+import {
+  getCanvases,
+  getVisibleCanvases,
+  getCompanionWindowsForPosition,
+  getAnnotationResourcesByMotivation,
+  getManifestSearchService,
+  getMiradorCanvasWrapper,
+  getSearchQuery,
+  getWindow,
+  getWindowConfig,
+} from '../state/selectors';
+import { WindowSideBarButtons } from '../components/WindowSideBarButtons';
+
+/**
+ * mapDispatchToProps - used to hook up connect to action creators
+ * @memberof WindowSideButtons
+ * @private
+ */
+const mapDispatchToProps = (dispatch, { windowId }) => ({
+  addCompanionWindow: (content) => dispatch(actions.addOrUpdateCompanionWindow(windowId, { content, position: 'left' })),
+});
+
+/** */
+function hasLayers(canvases, getMiradorCanvas) {
+  return canvases && canvases.some((c) => getMiradorCanvas(c).imageResources.length > 1);
+}
+
+/** */
+function hasAnnotations(canvases, getMiradorCanvas) {
+  return (
+    canvases &&
+    canvases.some((c) => {
+      const canvas = getMiradorCanvas(c);
+
+      return canvas.annotationListUris.length > 0 || canvas.canvasAnnotationPages.length > 0;
+    })
+  );
+}
+
+/** */
+function hasSearchResults(state, { windowId }) {
+  const { suggestedSearches } = getWindow(state, { windowId });
+  const companionWindowId = getCompanionWindowsForPosition(state, {
+    position: 'left',
+    windowId,
+  })?.[0]?.id;
+  const searchQuery = getSearchQuery(state, { companionWindowId, windowId });
+
+  return Boolean(suggestedSearches || searchQuery);
+}
+
+/**
+ * mapStateToProps - used to hook up connect to state
+ * @memberof WindowSideButtons
+ * @private
+ */
+const mapStateToProps = (state, { windowId }) => ({
+  hasAnnotations: getAnnotationResourcesByMotivation(state, { windowId }).length > 0,
+  hasAnyAnnotations: hasAnnotations(getCanvases(state, { windowId }), getMiradorCanvasWrapper(state)),
+  hasAnyLayers: hasLayers(getCanvases(state, { windowId }), getMiradorCanvasWrapper(state)),
+  hasCurrentLayers: hasLayers(getVisibleCanvases(state, { windowId }), getMiradorCanvasWrapper(state)),
+  hasSearchResults: hasSearchResults(state, { windowId }),
+  hasSearchService: getManifestSearchService(state, { windowId }) !== null,
+  panels: getWindowConfig(state, { windowId }).panels,
+  sideBarPanel: (getCompanionWindowsForPosition(state, { position: 'left', windowId })[0] || {}).content,
+});
+
+const enhance = compose(connect(mapStateToProps, mapDispatchToProps), withPlugins('WindowSideBarButtons'));
+
+export default enhance(WindowSideBarButtons);

package/src/containers/WindowSideBarCanvasPanel.js

@@ -0,0 +1,50 @@
+import { compose } from 'redux';
+import { connect } from 'react-redux';
+import { withPlugins } from '../extend/withPlugins';
+import * as actions from '../state/actions';
+import { WindowSideBarCanvasPanel } from '../components/WindowSideBarCanvasPanel';
+import {
+  getCompanionWindow,
+  getDefaultSidebarVariant,
+  getSequenceTreeStructure,
+  getWindow,
+  getManifestoInstance,
+  getSequence,
+  getSequences,
+} from '../state/selectors';
+
+/**
+ * mapStateToProps - to hook up connect
+ */
+const mapStateToProps = (state, { id, windowId }) => {
+  const treeStructure = getSequenceTreeStructure(state, { windowId });
+  const window = getWindow(state, { windowId });
+  const { config } = state;
+  const companionWindow = getCompanionWindow(state, { companionWindowId: id });
+  const collectionPath = window.collectionPath || [];
+  const collectionId = collectionPath && collectionPath[collectionPath.length - 1];
+  const sequence = getSequence(state, { windowId });
+  return {
+    collection: collectionId && getManifestoInstance(state, { manifestId: collectionId }),
+    config,
+    sequenceId: sequence && sequence.id,
+    sequences: getSequences(state, { windowId }),
+    showToc: treeStructure && treeStructure.nodes && treeStructure.nodes.length > 0,
+    variant: companionWindow.variant || getDefaultSidebarVariant(state, { windowId }),
+  };
+};
+
+/**
+ * mapStateToProps - used to hook up connect to state
+ * @memberof WindowSideBarCanvasPanel
+ * @private
+ */
+const mapDispatchToProps = (dispatch, { id, windowId }) => ({
+  showMultipart: () => dispatch(actions.addOrUpdateCompanionWindow(windowId, { content: 'collection', position: 'right' })),
+  updateSequence: (sequenceId) => dispatch(actions.updateWindow(windowId, { sequenceId })),
+  updateVariant: (variant) => dispatch(actions.updateCompanionWindow(windowId, id, { variant })),
+});
+
+const enhance = compose(connect(mapStateToProps, mapDispatchToProps), withPlugins('WindowSideBarCanvasPanel'));
+
+export default enhance(WindowSideBarCanvasPanel);

package/src/containers/WindowSideBarCollectionPanel.js

@@ -0,0 +1,48 @@
+import { compose } from 'redux';
+import { connect } from 'react-redux';
+import { withPlugins } from '../extend/withPlugins';
+import * as actions from '../state/actions';
+import { getCompanionWindow, getManifest, getManifestoInstance, getDefaultSidebarVariant, getWindow } from '../state/selectors';
+import { WindowSideBarCollectionPanel } from '../components/WindowSideBarCollectionPanel';
+
+/**
+ * mapStateToProps - to hook up connect
+ */
+const mapStateToProps = (state, { id, windowId }) => {
+  const window = getWindow(state, { windowId });
+  const companionWindow = getCompanionWindow(state, { companionWindowId: id });
+  const { collectionPath: localCollectionPath } = companionWindow;
+  const collectionPath = localCollectionPath || window.collectionPath;
+  const collectionId = collectionPath && collectionPath[collectionPath.length - 1];
+  const parentCollectionId = collectionPath && collectionPath[collectionPath.length - 2];
+  const collection = collectionId && getManifest(state, { manifestId: collectionId });
+  const parentCollection = parentCollectionId && getManifest(state, { manifestId: parentCollectionId });
+  const manifest = getManifest(state, { windowId });
+
+  return {
+    canvasNavigation: state.config.canvasNavigation,
+    collection: collection && getManifestoInstance(state, { manifestId: collection.id }),
+    collectionId,
+    collectionPath,
+    error: collection && collection.error,
+    isFetching: collection && collection.isFetching,
+    manifestId: manifest && manifest.id,
+    parentCollection: parentCollection && getManifestoInstance(state, { manifestId: parentCollection.id }),
+    ready: collection && !!collection.json,
+    variant: companionWindow.variant || getDefaultSidebarVariant(state, { windowId }),
+  };
+};
+
+/**
+ * mapStateToProps - used to hook up connect to state
+ * @memberof SidebarIndexList
+ * @private
+ */
+const mapDispatchToProps = (dispatch, { id, windowId }) => ({
+  updateCompanionWindow: (...args) => dispatch(actions.updateCompanionWindow(windowId, id, ...args)),
+  updateWindow: (...args) => dispatch(actions.updateWindow(windowId, ...args)),
+});
+
+const enhance = compose(connect(mapStateToProps, mapDispatchToProps), withPlugins('WindowSideBarCollectionPanel'));
+
+export default enhance(WindowSideBarCollectionPanel);

package/src/containers/WindowSideBarInfoPanel.js

@@ -0,0 +1,35 @@
+import { compose } from 'redux';
+import { connect } from 'react-redux';
+import { withPlugins } from '../extend/withPlugins';
+import * as actions from '../state/actions';
+import {
+  getCompanionWindow,
+  getManifestLocale,
+  getMetadataLocales,
+  getVisibleCanvasIds,
+  getWindowConfig,
+  getWindow,
+} from '../state/selectors';
+import { WindowSideBarInfoPanel } from '../components/WindowSideBarInfoPanel';
+
+/**
+ * mapStateToProps - to hook up connect
+ * @memberof WindowSideBarInfoPanel
+ * @private
+ */
+const mapStateToProps = (state, { id, windowId }) => ({
+  availableLocales: getMetadataLocales(state, { companionWindowId: id, windowId }),
+  canvasIds: getVisibleCanvasIds(state, { windowId }),
+  collectionPath: (getWindow(state, { windowId }) || {}).collectionPath,
+  locale: getCompanionWindow(state, { companionWindowId: id }).locale || getManifestLocale(state, { windowId }),
+  showLocalePicker: getWindowConfig(state, { windowId }).showLocalePicker,
+});
+
+/** */
+const mapDispatchToProps = (dispatch, { windowId, id }) => ({
+  setLocale: (locale) => dispatch(actions.updateCompanionWindow(windowId, id, { locale })),
+});
+
+const enhance = compose(connect(mapStateToProps, mapDispatchToProps), withPlugins('WindowSideBarInfoPanel'));
+
+export default enhance(WindowSideBarInfoPanel);

package/src/containers/WindowThumbnailSettings.js

@@ -0,0 +1,31 @@
+import { compose } from 'redux';
+import { connect } from 'react-redux';
+import { withPlugins } from '../extend/withPlugins';
+import * as actions from '../state/actions';
+import { getThumbnailNavigationPosition, getThemeDirection } from '../state/selectors';
+import { WindowThumbnailSettings } from '../components/WindowThumbnailSettings';
+
+/**
+ * mapDispatchToProps - used to hook up connect to action creators
+ * @memberof ManifestListItem
+ * @private
+ */
+const mapDispatchToProps = { setWindowThumbnailPosition: actions.setWindowThumbnailPosition };
+
+/**
+ * mapStateToProps - to hook up connect
+ * @memberof WindowViewer
+ * @private
+ */
+const mapStateToProps = (state, { windowId }) => ({
+  direction: getThemeDirection(state),
+  thumbnailNavigationPosition: getThumbnailNavigationPosition(state, { windowId }),
+});
+
+const enhance = compose(
+  connect(mapStateToProps, mapDispatchToProps, null, { forwardRef: true }),
+  withPlugins('WindowThumbnailSettings'),
+  // further HOC go here
+);
+
+export default enhance(WindowThumbnailSettings);

package/src/containers/WindowTopBar.js

@@ -0,0 +1,39 @@
+import { compose } from 'redux';
+import { connect } from 'react-redux';
+import { withPlugins } from '../extend/withPlugins';
+import * as actions from '../state/actions';
+import { getWindowConfig, isFocused, getWindow } from '../state/selectors';
+import { WindowTopBar } from '../components/WindowTopBar';
+
+/** mapStateToProps */
+const mapStateToProps = (state, { windowId }) => {
+  const config = getWindowConfig(state, { windowId });
+
+  return {
+    allowClose: config.allowClose,
+    allowFullscreen: config.allowFullscreen,
+    allowMaximize: config.allowMaximize,
+    allowTopMenuButton: config.allowTopMenuButton,
+    allowWindowSideBar: config.allowWindowSideBar,
+    focused: isFocused(state, { windowId }),
+    maximized: config.maximized,
+    sideBarOpen: (getWindow(state, { windowId }) || {}).sideBarOpen,
+  };
+};
+
+/**
+ * mapDispatchToProps - used to hook up connect to action creators
+ * @memberof ManifestListItem
+ * @private
+ */
+const mapDispatchToProps = (dispatch, { windowId }) => ({
+  focusWindow: () => dispatch(actions.focusWindow(windowId)),
+  maximizeWindow: () => dispatch(actions.maximizeWindow(windowId)),
+  minimizeWindow: () => dispatch(actions.minimizeWindow(windowId)),
+  removeWindow: () => dispatch(actions.removeWindow(windowId)),
+  toggleWindowSideBar: () => dispatch(actions.toggleWindowSideBar(windowId)),
+});
+
+const enhance = compose(connect(mapStateToProps, mapDispatchToProps), withPlugins('WindowTopBar'));
+
+export default enhance(WindowTopBar);

package/src/containers/WindowTopBarPluginArea.js

@@ -0,0 +1,8 @@
+import { compose } from 'redux';
+import { connect } from 'react-redux';
+import { withPlugins } from '../extend/withPlugins';
+import { WindowTopBarPluginArea } from '../components/WindowTopBarPluginArea';
+
+const enhance = compose(connect(null, null), withPlugins('WindowTopBarPluginArea'));
+
+export default enhance(WindowTopBarPluginArea);

package/src/containers/WindowTopBarPluginMenu.js

@@ -0,0 +1,7 @@
+import { compose } from 'redux';
+import { withPlugins } from '../extend/withPlugins';
+import { WindowTopBarPluginMenu } from '../components/WindowTopBarPluginMenu';
+
+const enhance = compose(withPlugins('WindowTopBarPluginMenu'));
+
+export default enhance(WindowTopBarPluginMenu);

package/src/containers/WindowTopBarTitle.js

@@ -0,0 +1,17 @@
+import { compose } from 'redux';
+import { connect } from 'react-redux';
+import { withPlugins } from '../extend/withPlugins';
+import { getManifestStatus, getManifestTitle, getWindowConfig } from '../state/selectors';
+import { WindowTopBarTitle } from '../components/WindowTopBarTitle';
+
+/** mapStateToProps */
+const mapStateToProps = (state, { windowId }) => ({
+  error: getManifestStatus(state, { windowId }).error,
+  hideWindowTitle: getWindowConfig(state, { windowId }).hideWindowTitle,
+  isFetching: getManifestStatus(state, { windowId }).isFetching,
+  manifestTitle: getManifestTitle(state, { windowId }),
+});
+
+const enhance = compose(connect(mapStateToProps, null), withPlugins('WindowTopBarTitle'));
+
+export default enhance(WindowTopBarTitle);