Fixed: Parse UHDBDRip as BluRay quality

Closes #7978

(cherry picked from commit 9ebe043bd94d036fe2ab45f3bb3f882cda48e211)

.gitignore

@@ -165,15 +165,12 @@ Thumbs.db
 /tools/Addins/*
 packages.config.md5sum
 
-
-# Common IntelliJ Platform excludes
-
-# Ignore Rider projects completely for now
-.idea/
-
 # ignore node_modules symlink
 node_modules
 node_modules.nosync
 
 # API doc generation
 .config/
+
+# Ignore Jetbrains IntelliJ Workspace Directories
+.idea/

azure-pipelines.yml

@@ -9,7 +9,7 @@ variables:
   testsFolder: './_tests'
   yarnCacheFolder: $(Pipeline.Workspace)/.yarn
   nugetCacheFolder: $(Pipeline.Workspace)/.nuget/packages
-  majorVersion: '5.22.3'
+  majorVersion: '5.27.4'
   minorVersion: $[counter('minorVersion', 2000)]
   radarrVersion: '$(majorVersion).$(minorVersion)'
   buildName: '$(Build.SourceBranchName).$(radarrVersion)'
@@ -481,6 +481,7 @@ stages:
           testResultsFiles: '**/TestResult.xml'
           testRunTitle: '$(testName) Unit Tests'
           failTaskOnFailedTests: true
+          failTaskOnMissingResultsFile: ne(variables['testName'], 'freebsd-x64')
 
     - job: Unit_Docker
       displayName: Unit Docker
@@ -540,7 +541,8 @@ stages:
           testResultsFiles: '**/TestResult.xml'
           testRunTitle: '$(testName) Unit Tests'
           failTaskOnFailedTests: true
-          
+          failTaskOnMissingResultsFile: true
+
     - job: Unit_LinuxCore_Postgres14
       displayName: Unit Native LinuxCore with Postgres14 Database
       dependsOn: Prepare
@@ -596,6 +598,7 @@ stages:
           testResultsFiles: '**/TestResult.xml'
           testRunTitle: 'LinuxCore Postgres14 Unit Tests'
           failTaskOnFailedTests: true
+          failTaskOnMissingResultsFile: true
 
     - job: Unit_LinuxCore_Postgres15
       displayName: Unit Native LinuxCore with Postgres15 Database
@@ -652,6 +655,7 @@ stages:
           testResultsFiles: '**/TestResult.xml'
           testRunTitle: 'LinuxCore Postgres15 Unit Tests'
           failTaskOnFailedTests: true
+          failTaskOnMissingResultsFile: true
 
   - stage: Integration
     displayName: Integration
@@ -734,6 +738,7 @@ stages:
           testResultsFiles: '**/TestResult.xml'
           testRunTitle: '$(testName) Integration Tests'
           failTaskOnFailedTests: true
+          failTaskOnMissingResultsFile: true
         displayName: Publish Test Results
 
     - job: Integration_LinuxCore_Postgres14
@@ -796,6 +801,7 @@ stages:
             testResultsFiles: '**/TestResult.xml'
             testRunTitle: 'Integration LinuxCore Postgres14 Database Integration Tests'
             failTaskOnFailedTests: true
+            failTaskOnMissingResultsFile: true
           displayName: Publish Test Results
 
 
@@ -859,6 +865,7 @@ stages:
             testResultsFiles: '**/TestResult.xml'
             testRunTitle: 'Integration LinuxCore Postgres15 Database Integration Tests'
             failTaskOnFailedTests: true
+            failTaskOnMissingResultsFile: true
           displayName: Publish Test Results
 
     - job: Integration_FreeBSD
@@ -905,6 +912,7 @@ stages:
           testResultsFiles: '**/TestResult.xml'
           testRunTitle: 'FreeBSD Integration Tests'
           failTaskOnFailedTests: true
+          failTaskOnMissingResultsFile: false
         displayName: Publish Test Results
 
     - job: Integration_Docker
@@ -974,6 +982,7 @@ stages:
           testResultsFiles: '**/TestResult.xml'
           testRunTitle: '$(testName) Integration Tests'
           failTaskOnFailedTests: true
+          failTaskOnMissingResultsFile: true
         displayName: Publish Test Results
 
   - stage: Automation
@@ -1055,6 +1064,7 @@ stages:
           testResultsFiles: '**/TestResult.xml'
           testRunTitle: '$(osName) Automation Tests'
           failTaskOnFailedTests: $(failBuild)
+          failTaskOnMissingResultsFile: $(failBuild)
         displayName: Publish Test Results
 
   - stage: Analyze

create_test_cases.py

@@ -1,44 +0,0 @@
-input1 = """Prometheus.Special.Edition.Fan Edit.2012..BRRip.x264.AAC-m2g
-Star Wars Episode IV - A New Hope (Despecialized) 1999.mkv
-Prometheus.(Special.Edition.Remastered).2012.[Bluray-1080p].mkv
-Prometheus Extended 2012
-Prometheus Extended Directors Cut Fan Edit 2012
-Prometheus Director's Cut 2012
-Prometheus Directors Cut 2012
-Prometheus.(Extended.Theatrical.Version.IMAX).BluRay.1080p.2012.asdf
-2001 A Space Odyssey Director's Cut (1968).mkv
-2001: A Space Odyssey (Extended Directors Cut FanEdit) Bluray 1080p 1968
-A Fake Movie 2035 Directors 2012.mkv
-Blade Runner Director's Cut 2049.mkv
-Prometheus 50th Anniversary Edition 2012.mkv
-Movie 2in1 2012.mkv
-Movie IMAX 2012.mkv"""
-
-output1 = """Special.Edition.Fan Edit     BRRip.x264.AAC-m2g
-Despecialized     mkv
-Special.Edition.Remastered     Bluray-1080p].mkv
-Extended     mkv
-Extended Directors Cut Fan Edit     mkv
-Director's Cut     mkv
-Directors Cut     mkv
-Extended.Theatrical.Version.IMAX     asdf
-Director's Cut     mkv
-Extended Directors Cut FanEdit     mkv
-Directors     mkv
-Director's Cut     mkv
-50th Anniversary Edition     mkv
-2in1     mkv
-IMAX     mkv"""
-
-inputs = input1.split("\n")
-outputs = output1.split("\n")
-real_o = []
-for output in outputs:
-    real_o.append(output.split("   ")[0].replace(".", " ").strip())
-
-count = 0
-
-for inp in inputs:
-    o = real_o[count]
-    print "[TestCase(\"{0}\", \"{1}\")]".format(inp, o)
-    count += 1

frontend/build/webpack.config.js

@@ -14,7 +14,6 @@ module.exports = (env) => {
   const srcFolder = path.join(frontendFolder, 'src');
   const isProduction = !!env.production;
   const isProfiling = isProduction && !!env.profile;
-  const inlineWebWorkers = 'no-fallback';
 
   const distFolder = path.resolve(frontendFolder, '..', '_output', uiFolder);
 
@@ -160,16 +159,6 @@ module.exports = (env) => {
 
     module: {
       rules: [
-        {
-          test: /\.worker\.js$/,
-          use: {
-            loader: 'worker-loader',
-            options: {
-              filename: '[name].js',
-              inline: inlineWebWorkers
-            }
-          }
-        },
         {
           test: [/\.jsx?$/, /\.tsx?$/],
           exclude: /(node_modules|JsLibraries)/,
@@ -187,7 +176,7 @@ module.exports = (env) => {
                       loose: true,
                       debug: false,
                       useBuiltIns: 'entry',
-                      corejs: '3.39'
+                      corejs: '3.42'
                     }
                   ]
                 ]

frontend/src/Activity/Blocklist/Blocklist.tsx

@@ -145,7 +145,7 @@ function Blocklist() {
   });
 
   const handleFilterSelect = useCallback(
-    (selectedFilterKey: string) => {
+    (selectedFilterKey: string | number) => {
       dispatch(setBlocklistFilter({ selectedFilterKey }));
     },
     [dispatch]

frontend/src/Activity/History/History.tsx

@@ -77,7 +77,7 @@ function History() {
   });
 
   const handleFilterSelect = useCallback(
-    (selectedFilterKey: string) => {
+    (selectedFilterKey: string | number) => {
       dispatch(setHistoryFilter({ selectedFilterKey }));
     },
     [dispatch]

frontend/src/Activity/Queue/Queue.tsx

@@ -183,7 +183,7 @@ function Queue() {
   });
 
   const handleFilterSelect = useCallback(
-    (selectedFilterKey: string) => {
+    (selectedFilterKey: string | number) => {
       dispatch(setQueueFilter({ selectedFilterKey }));
     },
     [dispatch]

frontend/src/Activity/Queue/QueueStatus.tsx

@@ -1,5 +1,5 @@
 import React from 'react';
-import Icon, { IconProps } from 'Components/Icon';
+import Icon, { IconKind } from 'Components/Icon';
 import Popover from 'Components/Tooltip/Popover';
 import { icons, kinds } from 'Helpers/Props';
 import { TooltipPosition } from 'Helpers/Props/tooltipPositions';
@@ -61,7 +61,7 @@ function QueueStatus(props: QueueStatusProps) {
 
   // status === 'downloading'
   let iconName = icons.DOWNLOADING;
-  let iconKind: IconProps['kind'] = kinds.DEFAULT;
+  let iconKind: IconKind = kinds.DEFAULT;
   let title = translate('Downloading');
 
   if (status === 'paused') {

frontend/src/AddMovie/ImportMovie/Import/ImportMovie.js

@@ -108,7 +108,7 @@ class ImportMovie extends Component {
           {
             !rootFoldersFetching && !!rootFoldersError ?
               <Alert kind={kinds.DANGER}>
-                {translate('UnableToLoadRootFolders')}
+                {translate('RootFoldersLoadError')}
               </Alert> :
               null
           }

frontend/src/AddMovie/ImportMovie/SelectFolder/ImportMovieSelectFolder.js

@@ -93,7 +93,7 @@ class ImportMovieSelectFolder extends Component {
           {
             !isFetching && error ?
               <Alert kind={kinds.DANGER}>
-                {translate('UnableToLoadRootFolders')}
+                {translate('RootFoldersLoadError')}
               </Alert> :
               null
           }

frontend/src/App/App.tsx

@@ -4,7 +4,7 @@ import React from 'react';
 import DocumentTitle from 'react-document-title';
 import { Provider } from 'react-redux';
 import { Store } from 'redux';
-import PageConnector from 'Components/Page/PageConnector';
+import Page from 'Components/Page/Page';
 import ApplyTheme from './ApplyTheme';
 import AppRoutes from './AppRoutes';
 
@@ -22,9 +22,9 @@ function App({ store, history }: AppProps) {
         <Provider store={store}>
           <ConnectedRouter history={history}>
             <ApplyTheme />
-            <PageConnector>
+            <Page>
               <AppRoutes />
-            </PageConnector>
+            </Page>
           </ConnectedRouter>
         </Provider>
       </QueryClientProvider>

frontend/src/App/AppRoutes.tsx

@@ -5,7 +5,7 @@ import History from 'Activity/History/History';
 import Queue from 'Activity/Queue/Queue';
 import AddNewMovieConnector from 'AddMovie/AddNewMovie/AddNewMovieConnector';
 import ImportMovies from 'AddMovie/ImportMovie/ImportMovies';
-import CalendarPageConnector from 'Calendar/CalendarPageConnector';
+import CalendarPage from 'Calendar/CalendarPage';
 import CollectionConnector from 'Collection/CollectionConnector';
 import NotFound from 'Components/NotFound';
 import Switch from 'Components/Router/Switch';
@@ -15,9 +15,9 @@ import MovieIndex from 'Movie/Index/MovieIndex';
 import CustomFormatSettingsPage from 'Settings/CustomFormats/CustomFormatSettingsPage';
 import DownloadClientSettingsConnector from 'Settings/DownloadClients/DownloadClientSettingsConnector';
 import GeneralSettingsConnector from 'Settings/General/GeneralSettingsConnector';
-import ImportListSettingsConnector from 'Settings/ImportLists/ImportListSettingsConnector';
-import IndexerSettingsConnector from 'Settings/Indexers/IndexerSettingsConnector';
-import MediaManagementConnector from 'Settings/MediaManagement/MediaManagementConnector';
+import ImportListSettings from 'Settings/ImportLists/ImportListSettings';
+import IndexerSettings from 'Settings/Indexers/IndexerSettings';
+import MediaManagement from 'Settings/MediaManagement/MediaManagement';
 import MetadataSettings from 'Settings/Metadata/MetadataSettings';
 import NotificationSettings from 'Settings/Notifications/NotificationSettings';
 import Profiles from 'Settings/Profiles/Profiles';
@@ -32,8 +32,8 @@ import Status from 'System/Status/Status';
 import Tasks from 'System/Tasks/Tasks';
 import Updates from 'System/Updates/Updates';
 import getPathWithUrlBase from 'Utilities/getPathWithUrlBase';
-import CutoffUnmetConnector from 'Wanted/CutoffUnmet/CutoffUnmetConnector';
-import MissingConnector from 'Wanted/Missing/MissingConnector';
+import CutoffUnmet from 'Wanted/CutoffUnmet/CutoffUnmet';
+import Missing from 'Wanted/Missing/Missing';
 
 function RedirectWithUrlBase() {
   return <Redirect to={getPathWithUrlBase('/')} />;
@@ -73,7 +73,7 @@ function AppRoutes() {
         Calendar
       */}
 
-      <Route path="/calendar" component={CalendarPageConnector} />
+      <Route path="/calendar" component={CalendarPage} />
 
       {/*
         Activity
@@ -89,9 +89,9 @@ function AppRoutes() {
         Wanted
       */}
 
-      <Route path="/wanted/missing" component={MissingConnector} />
+      <Route path="/wanted/missing" component={Missing} />
 
-      <Route path="/wanted/cutoffunmet" component={CutoffUnmetConnector} />
+      <Route path="/wanted/cutoffunmet" component={CutoffUnmet} />
 
       {/*
         Settings
@@ -99,10 +99,7 @@ function AppRoutes() {
 
       <Route exact={true} path="/settings" component={Settings} />
 
-      <Route
-        path="/settings/mediamanagement"
-        component={MediaManagementConnector}
-      />
+      <Route path="/settings/mediamanagement" component={MediaManagement} />
 
       <Route path="/settings/profiles" component={Profiles} />
 
@@ -113,17 +110,14 @@ function AppRoutes() {
         component={CustomFormatSettingsPage}
       />
 
-      <Route path="/settings/indexers" component={IndexerSettingsConnector} />
+      <Route path="/settings/indexers" component={IndexerSettings} />
 
       <Route
         path="/settings/downloadclients"
         component={DownloadClientSettingsConnector}
       />
 
-      <Route
-        path="/settings/importlists"
-        component={ImportListSettingsConnector}
-      />
+      <Route path="/settings/importlists" component={ImportListSettings} />
 
       <Route path="/settings/connect" component={NotificationSettings} />
 

frontend/src/App/SelectContext.tsx

@@ -9,13 +9,13 @@ export type SelectContextAction =
   | { type: 'unselectAll' }
   | {
       type: 'toggleSelected';
-      id: number;
-      isSelected: boolean;
+      id: number | string;
+      isSelected: boolean | null;
       shiftKey: boolean;
     }
   | {
       type: 'removeItem';
-      id: number;
+      id: number | string;
     }
   | {
       type: 'updateItems';

frontend/src/App/State/AppSectionState.ts

@@ -1,7 +1,7 @@
 import Column from 'Components/Table/Column';
 import { SortDirection } from 'Helpers/Props/sortDirections';
 import { ValidationFailure } from 'typings/pending';
-import { FilterBuilderProp, PropertyFilter } from './AppState';
+import { Filter, FilterBuilderProp } from './AppState';
 
 export interface Error {
   status?: number;
@@ -35,7 +35,7 @@ export interface TableAppSectionState {
 
 export interface AppSectionFilterState<T> {
   selectedFilterKey: string;
-  filters: PropertyFilter[];
+  filters: Filter[];
   filterBuilderProps: FilterBuilderProp<T>[];
 }
 
@@ -43,9 +43,15 @@ export interface AppSectionSchemaState<T> {
   isSchemaFetching: boolean;
   isSchemaPopulated: boolean;
   schemaError: Error;
-  schema: {
-    items: T[];
-  };
+  schema: T[];
+  selectedSchema?: T;
+}
+
+export interface AppSectionItemSchemaState<T> {
+  isSchemaFetching: boolean;
+  isSchemaPopulated: boolean;
+  schemaError: Error;
+  schema: T;
 }
 
 export interface AppSectionItemState<T> {
@@ -61,9 +67,10 @@ export interface AppSectionProviderState<T>
     AppSectionSaveState {
   isFetching: boolean;
   isPopulated: boolean;
+  isTesting?: boolean;
   error: Error;
   items: T[];
-  pendingChanges: Partial<T>;
+  pendingChanges?: Partial<T>;
 }
 
 interface AppSectionState<T> {

frontend/src/App/State/AppState.ts

@@ -1,10 +1,13 @@
+import { Error } from './AppSectionState';
 import BlocklistAppState from './BlocklistAppState';
 import CalendarAppState from './CalendarAppState';
 import CaptchaAppState from './CaptchaAppState';
 import CommandAppState from './CommandAppState';
+import CustomFiltersAppState from './CustomFiltersAppState';
 import ExtraFilesAppState from './ExtraFilesAppState';
 import HistoryAppState, { MovieHistoryAppState } from './HistoryAppState';
 import InteractiveImportAppState from './InteractiveImportAppState';
+import MessagesAppState from './MessagesAppState';
 import MovieBlocklistAppState from './MovieBlocklistAppState';
 import MovieCollectionAppState from './MovieCollectionAppState';
 import MovieCreditAppState from './MovieCreditAppState';
@@ -21,6 +24,7 @@ import RootFolderAppState from './RootFolderAppState';
 import SettingsAppState from './SettingsAppState';
 import SystemAppState from './SystemAppState';
 import TagsAppState from './TagsAppState';
+import WantedAppState from './WantedAppState';
 
 interface FilterBuilderPropOption {
   id: string;
@@ -43,28 +47,36 @@ export interface PropertyFilter {
 
 export interface Filter {
   key: string;
-  label: string;
-  filers: PropertyFilter[];
+  label: string | (() => string);
+  filters: PropertyFilter[];
 }
 
 export interface CustomFilter {
   id: number;
   type: string;
   label: string;
-  filers: PropertyFilter[];
+  filters: PropertyFilter[];
 }
 
 export interface AppSectionState {
+  isUpdated: boolean;
   isConnected: boolean;
+  isDisconnected: boolean;
   isReconnecting: boolean;
   isSidebarVisible: boolean;
   version: string;
   prevVersion?: string;
   dimensions: {
     isSmallScreen: boolean;
+    isLargeScreen: boolean;
     width: number;
     height: number;
   };
+  translations: {
+    error?: Error;
+    isPopulated: boolean;
+  };
+  messages: MessagesAppState;
 }
 
 interface AppState {
@@ -73,6 +85,7 @@ interface AppState {
   calendar: CalendarAppState;
   captcha: CaptchaAppState;
   commands: CommandAppState;
+  customFilters: CustomFiltersAppState;
   extraFiles: ExtraFilesAppState;
   history: HistoryAppState;
   interactiveImport: InteractiveImportAppState;
@@ -94,6 +107,7 @@ interface AppState {
   settings: SettingsAppState;
   system: SystemAppState;
   tags: TagsAppState;
+  wanted: WantedAppState;
 }
 
 export default AppState;

frontend/src/App/State/CalendarAppState.ts

@@ -1,10 +1,29 @@
+import moment from 'moment';
 import AppSectionState, {
   AppSectionFilterState,
 } from 'App/State/AppSectionState';
-import Movie from 'Movie/Movie';
+import { CalendarView } from 'Calendar/calendarViews';
+import { CalendarItem } from 'typings/Calendar';
+
+interface CalendarOptions {
+  showMovieInformation: boolean;
+  showCinemaRelease: boolean;
+  showDigitalRelease: boolean;
+  showPhysicalRelease: boolean;
+  showCutoffUnmetIcon: boolean;
+  fullColorEvents: boolean;
+}
 
 interface CalendarAppState
-  extends AppSectionState<Movie>,
-    AppSectionFilterState<Movie> {}
+  extends AppSectionState<CalendarItem>,
+    AppSectionFilterState<CalendarItem> {
+  searchMissingCommandId: number | null;
+  start: moment.Moment;
+  end: moment.Moment;
+  dates: string[];
+  time: string;
+  view: CalendarView;
+  options: CalendarOptions;
+}
 
 export default CalendarAppState;

frontend/src/App/State/MessagesAppState.ts

@@ -0,0 +1,15 @@
+import ModelBase from 'App/ModelBase';
+import AppSectionState from 'App/State/AppSectionState';
+
+export type MessageType = 'error' | 'info' | 'success' | 'warning';
+
+export interface Message extends ModelBase {
+  hideAfter: number;
+  message: string;
+  name: string;
+  type: MessageType;
+}
+
+type MessagesAppState = AppSectionState<Message>;
+
+export default MessagesAppState;

frontend/src/App/State/SettingsAppState.ts

@@ -1,12 +1,15 @@
 import AppSectionState, {
   AppSectionDeleteState,
+  AppSectionItemSchemaState,
   AppSectionItemState,
   AppSectionSaveState,
   AppSectionSchemaState,
   PagedAppSectionState,
 } from 'App/State/AppSectionState';
 import Language from 'Language/Language';
+import AutoTagging, { AutoTaggingSpecification } from 'typings/AutoTagging';
 import CustomFormat from 'typings/CustomFormat';
+import DelayProfile from 'typings/DelayProfile';
 import DownloadClient from 'typings/DownloadClient';
 import ImportList from 'typings/ImportList';
 import ImportListExclusion from 'typings/ImportListExclusion';
@@ -16,12 +19,34 @@ import IndexerFlag from 'typings/IndexerFlag';
 import Notification from 'typings/Notification';
 import QualityProfile from 'typings/QualityProfile';
 import General from 'typings/Settings/General';
+import IndexerOptions from 'typings/Settings/IndexerOptions';
+import MediaManagement from 'typings/Settings/MediaManagement';
 import NamingConfig from 'typings/Settings/NamingConfig';
 import NamingExample from 'typings/Settings/NamingExample';
 import ReleaseProfile from 'typings/Settings/ReleaseProfile';
 import UiSettings from 'typings/Settings/UiSettings';
 import MetadataAppState from './MetadataAppState';
 
+type Presets<T> = T & {
+  presets: T[];
+};
+
+export interface AutoTaggingAppState
+  extends AppSectionState<AutoTagging>,
+    AppSectionDeleteState,
+    AppSectionSaveState {}
+
+export interface AutoTaggingSpecificationAppState
+  extends AppSectionState<AutoTaggingSpecification>,
+    AppSectionDeleteState,
+    AppSectionSaveState,
+    AppSectionSchemaState<AutoTaggingSpecification> {}
+
+export interface DelayProfileAppState
+  extends AppSectionState<DelayProfile>,
+    AppSectionDeleteState,
+    AppSectionSaveState {}
+
 export interface DownloadClientAppState
   extends AppSectionState<DownloadClient>,
     AppSectionDeleteState,
@@ -33,6 +58,10 @@ export interface GeneralAppState
   extends AppSectionItemState<General>,
     AppSectionSaveState {}
 
+export interface MediaManagementAppState
+  extends AppSectionItemState<MediaManagement>,
+    AppSectionSaveState {}
+
 export interface NamingAppState
   extends AppSectionItemState<NamingConfig>,
     AppSectionSaveState {}
@@ -42,12 +71,20 @@ export type NamingExamplesAppState = AppSectionItemState<NamingExample>;
 export interface ImportListAppState
   extends AppSectionState<ImportList>,
     AppSectionDeleteState,
+    AppSectionSaveState,
+    AppSectionSchemaState<Presets<ImportList>> {
+  isTestingAll: boolean;
+}
+
+export interface IndexerOptionsAppState
+  extends AppSectionItemState<IndexerOptions>,
     AppSectionSaveState {}
 
 export interface IndexerAppState
   extends AppSectionState<Indexer>,
     AppSectionDeleteState,
-    AppSectionSaveState {
+    AppSectionSaveState,
+    AppSectionSchemaState<Presets<Indexer>> {
   isTestingAll: boolean;
 }
 
@@ -57,7 +94,7 @@ export interface NotificationAppState
 
 export interface QualityProfilesAppState
   extends AppSectionState<QualityProfile>,
-    AppSectionSchemaState<QualityProfile> {}
+    AppSectionItemSchemaState<QualityProfile> {}
 
 export interface ReleaseProfilesAppState
   extends AppSectionState<ReleaseProfile>,
@@ -88,15 +125,20 @@ export type UiSettingsAppState = AppSectionItemState<UiSettings>;
 
 interface SettingsAppState {
   advancedSettings: boolean;
+  autoTaggings: AutoTaggingAppState;
+  autoTaggingSpecifications: AutoTaggingSpecificationAppState;
   customFormats: CustomFormatAppState;
+  delayProfiles: DelayProfileAppState;
   downloadClients: DownloadClientAppState;
   general: GeneralAppState;
   importListExclusions: ImportListExclusionsSettingsAppState;
   importListOptions: ImportListOptionsSettingsAppState;
   importLists: ImportListAppState;
   indexerFlags: IndexerFlagSettingsAppState;
+  indexerOptions: IndexerOptionsAppState;
   indexers: IndexerAppState;
   languages: LanguageSettingsAppState;
+  mediaManagement: MediaManagementAppState;
   metadata: MetadataAppState;
   naming: NamingAppState;
   namingExamples: NamingExamplesAppState;

frontend/src/App/State/SystemAppState.ts

@@ -1,5 +1,6 @@
 import DiskSpace from 'typings/DiskSpace';
 import Health from 'typings/Health';
+import LogFile from 'typings/LogFile';
 import SystemStatus from 'typings/SystemStatus';
 import Task from 'typings/Task';
 import Update from 'typings/Update';
@@ -9,13 +10,16 @@ export type DiskSpaceAppState = AppSectionState<DiskSpace>;
 export type HealthAppState = AppSectionState<Health>;
 export type SystemStatusAppState = AppSectionItemState<SystemStatus>;
 export type TaskAppState = AppSectionState<Task>;
+export type LogFilesAppState = AppSectionState<LogFile>;
 export type UpdateAppState = AppSectionState<Update>;
 
 interface SystemAppState {
   diskSpace: DiskSpaceAppState;
   health: HealthAppState;
+  logFiles: LogFilesAppState;
   status: SystemStatusAppState;
   tasks: TaskAppState;
+  updateLogFiles: LogFilesAppState;
   updates: UpdateAppState;
 }
 

frontend/src/App/State/TagsAppState.ts

@@ -17,7 +17,7 @@ export interface TagDetail extends ModelBase {
   indexerIds: number[];
   movieIds: number[];
   notificationIds: number[];
-  restrictionIds: number[];
+  releaseProfileIds: number[];
 }
 
 export interface TagDetailAppState

frontend/src/App/State/WantedAppState.ts

@@ -0,0 +1,29 @@
+import AppSectionState, {
+  AppSectionFilterState,
+  PagedAppSectionState,
+  TableAppSectionState,
+} from 'App/State/AppSectionState';
+import Movie from 'Movie/Movie';
+
+interface WantedMovie extends Movie {
+  isSaving?: boolean;
+}
+
+interface WantedCutoffUnmetAppState
+  extends AppSectionState<WantedMovie>,
+    AppSectionFilterState<WantedMovie>,
+    PagedAppSectionState,
+    TableAppSectionState {}
+
+interface WantedMissingAppState
+  extends AppSectionState<WantedMovie>,
+    AppSectionFilterState<WantedMovie>,
+    PagedAppSectionState,
+    TableAppSectionState {}
+
+interface WantedAppState {
+  cutoffUnmet: WantedCutoffUnmetAppState;
+  missing: WantedMissingAppState;
+}
+
+export default WantedAppState;

frontend/src/Calendar/Agenda/Agenda.js

@@ -1,69 +0,0 @@
-import moment from 'moment';
-import PropTypes from 'prop-types';
-import React from 'react';
-import AgendaEventConnector from './AgendaEventConnector';
-import styles from './Agenda.css';
-
-function Agenda(props) {
-  const {
-    items,
-    start,
-    end
-  } = props;
-
-  const startDateParsed = Date.parse(start);
-  const endDateParsed = Date.parse(end);
-
-  items.forEach((item) => {
-    const cinemaDateParsed = Date.parse(item.inCinemas);
-    const digitalDateParsed = Date.parse(item.digitalRelease);
-    const physicalDateParsed = Date.parse(item.physicalRelease);
-    const dates = [];
-
-    if (cinemaDateParsed > 0 && cinemaDateParsed >= startDateParsed && cinemaDateParsed <= endDateParsed) {
-      dates.push(cinemaDateParsed);
-    }
-    if (digitalDateParsed > 0 && digitalDateParsed >= startDateParsed && digitalDateParsed <= endDateParsed) {
-      dates.push(digitalDateParsed);
-    }
-    if (physicalDateParsed > 0 && physicalDateParsed >= startDateParsed && physicalDateParsed <= endDateParsed) {
-      dates.push(physicalDateParsed);
-    }
-
-    item.sortDate = Math.min(...dates);
-    item.cinemaDateParsed = cinemaDateParsed;
-    item.digitalDateParsed = digitalDateParsed;
-    item.physicalDateParsed = physicalDateParsed;
-  });
-
-  items.sort((a, b) => ((a.sortDate > b.sortDate) ? 1 : -1));
-
-  return (
-    <div className={styles.agenda}>
-      {
-        items.map((item, index) => {
-          const momentDate = moment(item.sortDate);
-          const showDate = index === 0 ||
-            !moment(items[index - 1].sortDate).isSame(momentDate, 'day');
-
-          return (
-            <AgendaEventConnector
-              key={item.id}
-              movieId={item.id}
-              showDate={showDate}
-              {...item}
-            />
-          );
-        })
-      }
-    </div>
-  );
-}
-
-Agenda.propTypes = {
-  items: PropTypes.arrayOf(PropTypes.object).isRequired,
-  start: PropTypes.string.isRequired,
-  end: PropTypes.string.isRequired
-};
-
-export default Agenda;

frontend/src/Calendar/Agenda/Agenda.tsx

@@ -0,0 +1,81 @@
+import moment from 'moment';
+import React, { useMemo } from 'react';
+import { useSelector } from 'react-redux';
+import AppState from 'App/State/AppState';
+import Movie from 'Movie/Movie';
+import AgendaEvent from './AgendaEvent';
+import styles from './Agenda.css';
+
+interface AgendaMovie extends Movie {
+  sortDate: moment.Moment;
+}
+
+function Agenda() {
+  const { start, end, items } = useSelector(
+    (state: AppState) => state.calendar
+  );
+
+  const events = useMemo(() => {
+    const result = items.map((item): AgendaMovie => {
+      const { inCinemas, digitalRelease, physicalRelease } = item;
+
+      const dates = [];
+
+      if (inCinemas) {
+        const inCinemasMoment = moment(inCinemas);
+
+        if (inCinemasMoment.isAfter(start) && inCinemasMoment.isBefore(end)) {
+          dates.push(inCinemasMoment);
+        }
+      }
+
+      if (digitalRelease) {
+        const digitalReleaseMoment = moment(digitalRelease);
+
+        if (
+          digitalReleaseMoment.isAfter(start) &&
+          digitalReleaseMoment.isBefore(end)
+        ) {
+          dates.push(digitalReleaseMoment);
+        }
+      }
+
+      if (physicalRelease) {
+        const physicalReleaseMoment = moment(physicalRelease);
+
+        if (
+          physicalReleaseMoment.isAfter(start) &&
+          physicalReleaseMoment.isBefore(end)
+        ) {
+          dates.push(physicalReleaseMoment);
+        }
+      }
+
+      const sortDate = moment.min(...dates);
+
+      return {
+        ...item,
+        sortDate,
+      };
+    });
+
+    result.sort((a, b) => (a.sortDate > b.sortDate ? 1 : -1));
+
+    return result;
+  }, [items, start, end]);
+
+  return (
+    <div className={styles.agenda}>
+      {events.map((item, index) => {
+        const momentDate = moment(item.sortDate);
+        const showDate =
+          index === 0 ||
+          !moment(events[index - 1].sortDate).isSame(momentDate, 'day');
+
+        return <AgendaEvent key={item.id} showDate={showDate} {...item} />;
+      })}
+    </div>
+  );
+}
+
+export default Agenda;

frontend/src/Calendar/Agenda/AgendaConnector.js

@@ -1,14 +0,0 @@
-import { connect } from 'react-redux';
-import { createSelector } from 'reselect';
-import Agenda from './Agenda';
-
-function createMapStateToProps() {
-  return createSelector(
-    (state) => state.calendar,
-    (calendar) => {
-      return calendar;
-    }
-  );
-}
-
-export default connect(createMapStateToProps)(Agenda);

frontend/src/Calendar/Agenda/AgendaEvent.css

@@ -53,6 +53,13 @@
   margin-right: 10px;
 }
 
+.releaseIcon {
+  margin-right: 20px;
+  width: 25px;
+  cursor: default;
+  pointer-events: all;
+}
+
 .statusIcon {
   margin-left: 3px;
   cursor: default;
@@ -107,8 +114,3 @@
     flex: 0 0 100%;
   }
 }
-
-.releaseIcon {
-  margin-right: 20px;
-  width: 25px;
-}

frontend/src/Calendar/Agenda/AgendaEvent.js

@@ -1,190 +0,0 @@
-import classNames from 'classnames';
-import moment from 'moment';
-import PropTypes from 'prop-types';
-import React, { Component } from 'react';
-import CalendarEventQueueDetails from 'Calendar/Events/CalendarEventQueueDetails';
-import getStatusStyle from 'Calendar/getStatusStyle';
-import Icon from 'Components/Icon';
-import Link from 'Components/Link/Link';
-import { icons, kinds } from 'Helpers/Props';
-import translate from 'Utilities/String/translate';
-import styles from './AgendaEvent.css';
-
-class AgendaEvent extends Component {
-  //
-  // Lifecycle
-
-  constructor(props, context) {
-    super(props, context);
-
-    this.state = {
-      isDetailsModalOpen: false
-    };
-  }
-
-  //
-  // Listeners
-
-  onPress = () => {
-    this.setState({ isDetailsModalOpen: true });
-  };
-
-  onDetailsModalClose = () => {
-    this.setState({ isDetailsModalOpen: false });
-  };
-
-  //
-  // Render
-
-  render() {
-    const {
-      movieFile,
-      title,
-      titleSlug,
-      genres,
-      isAvailable,
-      inCinemas,
-      digitalRelease,
-      physicalRelease,
-      monitored,
-      hasFile,
-      grabbed,
-      queueItem,
-      showDate,
-      showMovieInformation,
-      showCutoffUnmetIcon,
-      longDateFormat,
-      colorImpairedMode,
-      cinemaDateParsed,
-      digitalDateParsed,
-      physicalDateParsed,
-      sortDate
-    } = this.props;
-
-    let startTime = null;
-    let releaseIcon = null;
-
-    if (physicalDateParsed === sortDate) {
-      startTime = physicalRelease;
-      releaseIcon = icons.DISC;
-    }
-
-    if (digitalDateParsed === sortDate) {
-      startTime = digitalRelease;
-      releaseIcon = icons.MOVIE_FILE;
-    }
-
-    if (cinemaDateParsed === sortDate) {
-      startTime = inCinemas;
-      releaseIcon = icons.IN_CINEMAS;
-    }
-
-    startTime = moment(startTime);
-    const downloading = !!(queueItem || grabbed);
-    const isMonitored = monitored;
-    const statusStyle = getStatusStyle(hasFile, downloading, isMonitored, isAvailable);
-    const joinedGenres = genres.slice(0, 2).join(', ');
-    const link = `/movie/${titleSlug}`;
-
-    return (
-      <div className={styles.event}>
-        <Link
-          className={styles.underlay}
-          to={link}
-        />
-
-        <div className={styles.overlay}>
-          <div className={styles.date}>
-            {showDate ? startTime.format(longDateFormat) : null}
-          </div>
-
-          <div className={styles.releaseIcon}>
-            <Icon
-              name={releaseIcon}
-              kind={kinds.DEFAULT}
-            />
-          </div>
-
-          <div
-            className={classNames(
-              styles.eventWrapper,
-              styles[statusStyle],
-              colorImpairedMode && 'colorImpaired'
-            )}
-          >
-            <div className={styles.movieTitle}>
-              {title}
-            </div>
-
-            {
-              showMovieInformation &&
-                <div className={styles.genres}>
-                  {joinedGenres}
-                </div>
-            }
-
-            {
-              !!queueItem &&
-                <span className={styles.statusIcon}>
-                  <CalendarEventQueueDetails
-                    {...queueItem}
-                  />
-                </span>
-            }
-
-            {
-              !queueItem && grabbed &&
-                <Icon
-                  className={styles.statusIcon}
-                  name={icons.DOWNLOADING}
-                  title={translate('MovieIsDownloading')}
-                />
-            }
-
-            {
-              showCutoffUnmetIcon && !!movieFile && movieFile.qualityCutoffNotMet &&
-                <Icon
-                  className={styles.statusIcon}
-                  name={icons.MOVIE_FILE}
-                  kind={kinds.WARNING}
-                  title={translate('QualityCutoffNotMet')}
-                />
-            }
-          </div>
-        </div>
-      </div>
-    );
-  }
-}
-
-AgendaEvent.propTypes = {
-  id: PropTypes.number.isRequired,
-  movieFile: PropTypes.object,
-  title: PropTypes.string.isRequired,
-  titleSlug: PropTypes.string.isRequired,
-  genres: PropTypes.arrayOf(PropTypes.string).isRequired,
-  isAvailable: PropTypes.bool.isRequired,
-  inCinemas: PropTypes.string,
-  digitalRelease: PropTypes.string,
-  physicalRelease: PropTypes.string,
-  monitored: PropTypes.bool.isRequired,
-  hasFile: PropTypes.bool.isRequired,
-  grabbed: PropTypes.bool,
-  queueItem: PropTypes.object,
-  showDate: PropTypes.bool.isRequired,
-  showMovieInformation: PropTypes.bool.isRequired,
-  showCutoffUnmetIcon: PropTypes.bool.isRequired,
-  timeFormat: PropTypes.string.isRequired,
-  longDateFormat: PropTypes.string.isRequired,
-  colorImpairedMode: PropTypes.bool.isRequired,
-  cinemaDateParsed: PropTypes.number,
-  digitalDateParsed: PropTypes.number,
-  physicalDateParsed: PropTypes.number,
-  sortDate: PropTypes.number
-};
-
-AgendaEvent.defaultProps = {
-  genres: []
-};
-
-export default AgendaEvent;

frontend/src/Calendar/Agenda/AgendaEvent.tsx

@@ -0,0 +1,160 @@
+import classNames from 'classnames';
+import moment from 'moment';
+import React, { useMemo } from 'react';
+import { useSelector } from 'react-redux';
+import AppState from 'App/State/AppState';
+import CalendarEventQueueDetails from 'Calendar/Events/CalendarEventQueueDetails';
+import getStatusStyle from 'Calendar/getStatusStyle';
+import Icon from 'Components/Icon';
+import Link from 'Components/Link/Link';
+import { icons, kinds } from 'Helpers/Props';
+import useMovieFile from 'MovieFile/useMovieFile';
+import { createQueueItemSelectorForHook } from 'Store/Selectors/createQueueItemSelector';
+import createUISettingsSelector from 'Store/Selectors/createUISettingsSelector';
+import translate from 'Utilities/String/translate';
+import styles from './AgendaEvent.css';
+
+interface AgendaEventProps {
+  id: number;
+  movieFileId: number;
+  title: string;
+  titleSlug: string;
+  genres: string[];
+  inCinemas?: string;
+  digitalRelease?: string;
+  physicalRelease?: string;
+  sortDate: moment.Moment;
+  isAvailable: boolean;
+  monitored: boolean;
+  hasFile: boolean;
+  grabbed?: boolean;
+  showDate: boolean;
+}
+
+function AgendaEvent({
+  id,
+  movieFileId,
+  title,
+  titleSlug,
+  genres = [],
+  inCinemas,
+  digitalRelease,
+  physicalRelease,
+  sortDate,
+  isAvailable,
+  monitored: isMonitored,
+  hasFile,
+  grabbed,
+  showDate,
+}: AgendaEventProps) {
+  const movieFile = useMovieFile(movieFileId);
+  const queueItem = useSelector(createQueueItemSelectorForHook(id));
+  const { longDateFormat, enableColorImpairedMode } = useSelector(
+    createUISettingsSelector()
+  );
+
+  const { showMovieInformation, showCutoffUnmetIcon } = useSelector(
+    (state: AppState) => state.calendar.options
+  );
+
+  const { eventDate, eventTitle, releaseIcon } = useMemo(() => {
+    if (physicalRelease && sortDate.isSame(moment(physicalRelease), 'day')) {
+      return {
+        eventDate: physicalRelease,
+        eventTitle: translate('PhysicalRelease'),
+        releaseIcon: icons.DISC,
+      };
+    }
+
+    if (digitalRelease && sortDate.isSame(moment(digitalRelease), 'day')) {
+      return {
+        eventDate: digitalRelease,
+        eventTitle: translate('DigitalRelease'),
+        releaseIcon: icons.MOVIE_FILE,
+      };
+    }
+
+    if (inCinemas && sortDate.isSame(moment(inCinemas), 'day')) {
+      return {
+        eventDate: inCinemas,
+        eventTitle: translate('InCinemas'),
+        releaseIcon: icons.IN_CINEMAS,
+      };
+    }
+
+    return {
+      eventDate: null,
+      eventTitle: null,
+      releaseIcon: null,
+    };
+  }, [inCinemas, digitalRelease, physicalRelease, sortDate]);
+
+  const downloading = !!(queueItem || grabbed);
+  const statusStyle = getStatusStyle(
+    hasFile,
+    downloading,
+    isMonitored,
+    isAvailable
+  );
+  const joinedGenres = genres.slice(0, 2).join(', ');
+  const link = `/movie/${titleSlug}`;
+
+  return (
+    <div className={styles.event}>
+      <Link className={styles.underlay} to={link} />
+
+      <div className={styles.overlay}>
+        <div className={styles.date}>
+          {showDate && eventDate
+            ? moment(eventDate).format(longDateFormat)
+            : null}
+        </div>
+
+        <div className={styles.releaseIcon}>
+          {releaseIcon ? (
+            <Icon name={releaseIcon} kind={kinds.DEFAULT} title={eventTitle} />
+          ) : null}
+        </div>
+
+        <div
+          className={classNames(
+            styles.eventWrapper,
+            styles[statusStyle],
+            enableColorImpairedMode && 'colorImpaired'
+          )}
+        >
+          <div className={styles.movieTitle}>{title}</div>
+
+          {showMovieInformation ? (
+            <div className={styles.genres}>{joinedGenres}</div>
+          ) : null}
+
+          {queueItem ? (
+            <span className={styles.statusIcon}>
+              <CalendarEventQueueDetails {...queueItem} />
+            </span>
+          ) : null}
+
+          {!queueItem && grabbed ? (
+            <Icon
+              className={styles.statusIcon}
+              name={icons.DOWNLOADING}
+              title={translate('MovieIsDownloading')}
+            />
+          ) : null}
+
+          {showCutoffUnmetIcon && movieFile && movieFile.qualityCutoffNotMet ? (
+            <Icon
+              className={styles.statusIcon}
+              name={icons.MOVIE_FILE}
+              kind={kinds.WARNING}
+              title={translate('QualityCutoffNotMet')}
+            />
+          ) : null}
+        </div>
+      </div>
+    </div>
+  );
+}
+
+export default AgendaEvent;

frontend/src/Calendar/Agenda/AgendaEventConnector.js

@@ -1,30 +0,0 @@
-import { connect } from 'react-redux';
-import { createSelector } from 'reselect';
-import createMovieFileSelector from 'Store/Selectors/createMovieFileSelector';
-import createMovieSelector from 'Store/Selectors/createMovieSelector';
-import createQueueItemSelector from 'Store/Selectors/createQueueItemSelector';
-import createUISettingsSelector from 'Store/Selectors/createUISettingsSelector';
-import AgendaEvent from './AgendaEvent';
-
-function createMapStateToProps() {
-  return createSelector(
-    (state) => state.calendar.options,
-    createMovieSelector(),
-    createMovieFileSelector(),
-    createQueueItemSelector(),
-    createUISettingsSelector(),
-    (calendarOptions, movie, movieFile, queueItem, uiSettings) => {
-      return {
-        movie,
-        movieFile,
-        queueItem,
-        ...calendarOptions,
-        timeFormat: uiSettings.timeFormat,
-        longDateFormat: uiSettings.longDateFormat,
-        colorImpairedMode: uiSettings.enableColorImpairedMode
-      };
-    }
-  );
-}
-
-export default connect(createMapStateToProps)(AgendaEvent);

frontend/src/Calendar/Calendar.js

@@ -1,67 +0,0 @@
-import PropTypes from 'prop-types';
-import React, { Component } from 'react';
-import Alert from 'Components/Alert';
-import LoadingIndicator from 'Components/Loading/LoadingIndicator';
-import { kinds } from 'Helpers/Props';
-import translate from 'Utilities/String/translate';
-import AgendaConnector from './Agenda/AgendaConnector';
-import * as calendarViews from './calendarViews';
-import CalendarDaysConnector from './Day/CalendarDaysConnector';
-import DaysOfWeekConnector from './Day/DaysOfWeekConnector';
-import CalendarHeaderConnector from './Header/CalendarHeaderConnector';
-import styles from './Calendar.css';
-
-class Calendar extends Component {
-
-  //
-  // Render
-
-  render() {
-    const {
-      isFetching,
-      isPopulated,
-      error,
-      view
-    } = this.props;
-
-    return (
-      <div className={styles.calendar}>
-        {
-          isFetching && !isPopulated &&
-            <LoadingIndicator />
-        }
-
-        {
-          !isFetching && !!error &&
-            <Alert kind={kinds.DANGER}>{translate('CalendarLoadError')}</Alert>
-        }
-
-        {
-          !error && isPopulated && view === calendarViews.AGENDA &&
-            <div className={styles.calendarContent}>
-              <CalendarHeaderConnector />
-              <AgendaConnector />
-            </div>
-        }
-
-        {
-          !error && isPopulated && view !== calendarViews.AGENDA &&
-            <div className={styles.calendarContent}>
-              <CalendarHeaderConnector />
-              <DaysOfWeekConnector />
-              <CalendarDaysConnector />
-            </div>
-        }
-      </div>
-    );
-  }
-}
-
-Calendar.propTypes = {
-  isFetching: PropTypes.bool.isRequired,
-  isPopulated: PropTypes.bool.isRequired,
-  error: PropTypes.object,
-  view: PropTypes.string.isRequired
-};
-
-export default Calendar;

frontend/src/Calendar/Calendar.tsx

@@ -0,0 +1,164 @@
+import React, { useCallback, useEffect, useRef } from 'react';
+import { useDispatch, useSelector } from 'react-redux';
+import AppState from 'App/State/AppState';
+import * as commandNames from 'Commands/commandNames';
+import Alert from 'Components/Alert';
+import LoadingIndicator from 'Components/Loading/LoadingIndicator';
+import useCurrentPage from 'Helpers/Hooks/useCurrentPage';
+import usePrevious from 'Helpers/Hooks/usePrevious';
+import { kinds } from 'Helpers/Props';
+import Movie from 'Movie/Movie';
+import {
+  clearCalendar,
+  fetchCalendar,
+  gotoCalendarToday,
+} from 'Store/Actions/calendarActions';
+import {
+  clearMovieFiles,
+  fetchMovieFiles,
+} from 'Store/Actions/movieFileActions';
+import {
+  clearQueueDetails,
+  fetchQueueDetails,
+} from 'Store/Actions/queueActions';
+import createCommandExecutingSelector from 'Store/Selectors/createCommandExecutingSelector';
+import hasDifferentItems from 'Utilities/Object/hasDifferentItems';
+import selectUniqueIds from 'Utilities/Object/selectUniqueIds';
+import {
+  registerPagePopulator,
+  unregisterPagePopulator,
+} from 'Utilities/pagePopulator';
+import translate from 'Utilities/String/translate';
+import Agenda from './Agenda/Agenda';
+import CalendarDays from './Day/CalendarDays';
+import DaysOfWeek from './Day/DaysOfWeek';
+import CalendarHeader from './Header/CalendarHeader';
+import styles from './Calendar.css';
+
+const UPDATE_DELAY = 3600000; // 1 hour
+
+function Calendar() {
+  const dispatch = useDispatch();
+  const requestCurrentPage = useCurrentPage();
+  const updateTimeout = useRef<ReturnType<typeof setTimeout>>();
+
+  const { isFetching, isPopulated, error, items, time, view } = useSelector(
+    (state: AppState) => state.calendar
+  );
+
+  const isRefreshingMovie = useSelector(
+    createCommandExecutingSelector(commandNames.REFRESH_MOVIE)
+  );
+
+  const firstDayOfWeek = useSelector(
+    (state: AppState) => state.settings.ui.item.firstDayOfWeek
+  );
+
+  const wasRefreshingMovie = usePrevious(isRefreshingMovie);
+  const previousFirstDayOfWeek = usePrevious(firstDayOfWeek);
+  const previousItems = usePrevious(items);
+
+  const handleScheduleUpdate = useCallback(() => {
+    clearTimeout(updateTimeout.current);
+
+    function updateCalendar() {
+      dispatch(gotoCalendarToday());
+      updateTimeout.current = setTimeout(updateCalendar, UPDATE_DELAY);
+    }
+
+    updateTimeout.current = setTimeout(updateCalendar, UPDATE_DELAY);
+  }, [dispatch]);
+
+  useEffect(() => {
+    handleScheduleUpdate();
+
+    return () => {
+      dispatch(clearCalendar());
+      dispatch(clearQueueDetails());
+      dispatch(clearMovieFiles());
+      clearTimeout(updateTimeout.current);
+    };
+  }, [dispatch, handleScheduleUpdate]);
+
+  useEffect(() => {
+    if (requestCurrentPage) {
+      dispatch(fetchCalendar());
+    } else {
+      dispatch(gotoCalendarToday());
+    }
+  }, [requestCurrentPage, dispatch]);
+
+  useEffect(() => {
+    const repopulate = () => {
+      dispatch(fetchQueueDetails({ time, view }));
+      dispatch(fetchCalendar({ time, view }));
+    };
+
+    registerPagePopulator(repopulate, ['movieFileUpdated', 'movieFileDeleted']);
+
+    return () => {
+      unregisterPagePopulator(repopulate);
+    };
+  }, [time, view, dispatch]);
+
+  useEffect(() => {
+    handleScheduleUpdate();
+  }, [time, handleScheduleUpdate]);
+
+  useEffect(() => {
+    if (
+      previousFirstDayOfWeek != null &&
+      firstDayOfWeek !== previousFirstDayOfWeek
+    ) {
+      dispatch(fetchCalendar({ time, view }));
+    }
+  }, [time, view, firstDayOfWeek, previousFirstDayOfWeek, dispatch]);
+
+  useEffect(() => {
+    if (wasRefreshingMovie && !isRefreshingMovie) {
+      dispatch(fetchCalendar({ time, view }));
+    }
+  }, [time, view, isRefreshingMovie, wasRefreshingMovie, dispatch]);
+
+  useEffect(() => {
+    if (!previousItems || hasDifferentItems(items, previousItems)) {
+      const movieIds = selectUniqueIds<Movie, number>(items, 'id');
+      const movieFileIds = selectUniqueIds<Movie, number>(items, 'movieFileId');
+
+      if (items.length) {
+        dispatch(fetchQueueDetails({ movieIds }));
+      }
+
+      if (movieFileIds.length) {
+        dispatch(fetchMovieFiles({ movieFileIds }));
+      }
+    }
+  }, [items, previousItems, dispatch]);
+
+  return (
+    <div className={styles.calendar}>
+      {isFetching && !isPopulated ? <LoadingIndicator /> : null}
+
+      {!isFetching && error ? (
+        <Alert kind={kinds.DANGER}>{translate('CalendarLoadError')}</Alert>
+      ) : null}
+
+      {!error && isPopulated && view === 'agenda' ? (
+        <div className={styles.calendarContent}>
+          <CalendarHeader />
+          <Agenda />
+        </div>
+      ) : null}
+
+      {!error && isPopulated && view !== 'agenda' ? (
+        <div className={styles.calendarContent}>
+          <CalendarHeader />
+          <DaysOfWeek />
+          <CalendarDays />
+        </div>
+      ) : null}
+    </div>
+  );
+}
+
+export default Calendar;

frontend/src/Calendar/CalendarConnector.js

@@ -1,195 +0,0 @@
-import PropTypes from 'prop-types';
-import React, { Component } from 'react';
-import { connect } from 'react-redux';
-import { createSelector } from 'reselect';
-import * as commandNames from 'Commands/commandNames';
-import * as calendarActions from 'Store/Actions/calendarActions';
-import { clearMovieFiles, fetchMovieFiles } from 'Store/Actions/movieFileActions';
-import { clearQueueDetails, fetchQueueDetails } from 'Store/Actions/queueActions';
-import createCommandExecutingSelector from 'Store/Selectors/createCommandExecutingSelector';
-import hasDifferentItems from 'Utilities/Object/hasDifferentItems';
-import selectUniqueIds from 'Utilities/Object/selectUniqueIds';
-import { registerPagePopulator, unregisterPagePopulator } from 'Utilities/pagePopulator';
-import Calendar from './Calendar';
-
-const UPDATE_DELAY = 3600000; // 1 hour
-
-function createMapStateToProps() {
-  return createSelector(
-    (state) => state.calendar,
-    (state) => state.settings.ui.item.firstDayOfWeek,
-    createCommandExecutingSelector(commandNames.REFRESH_MOVIE),
-    (calendar, firstDayOfWeek, isRefreshingMovie) => {
-      return {
-        ...calendar,
-        isRefreshingMovie,
-        firstDayOfWeek
-      };
-    }
-  );
-}
-
-const mapDispatchToProps = {
-  ...calendarActions,
-  fetchMovieFiles,
-  clearMovieFiles,
-  fetchQueueDetails,
-  clearQueueDetails
-};
-
-class CalendarConnector extends Component {
-
-  //
-  // Lifecycle
-
-  constructor(props, context) {
-    super(props, context);
-
-    this.updateTimeoutId = null;
-  }
-
-  componentDidMount() {
-    const {
-      useCurrentPage,
-      fetchCalendar,
-      gotoCalendarToday
-    } = this.props;
-
-    registerPagePopulator(this.repopulate, ['movieFileUpdated', 'movieFileDeleted']);
-
-    if (useCurrentPage) {
-      fetchCalendar();
-    } else {
-      gotoCalendarToday();
-    }
-
-    this.scheduleUpdate();
-  }
-
-  componentDidUpdate(prevProps) {
-    const {
-      items,
-      time,
-      view,
-      isRefreshingMovie,
-      firstDayOfWeek
-    } = this.props;
-
-    if (hasDifferentItems(prevProps.items, items)) {
-      const movieFileIds = selectUniqueIds(items, 'movieFileId');
-
-      if (movieFileIds.length) {
-        this.props.fetchMovieFiles({ movieFileIds });
-      }
-
-      if (items.length) {
-        this.props.fetchQueueDetails();
-      }
-    }
-
-    if (prevProps.time !== time) {
-      this.scheduleUpdate();
-    }
-
-    if (prevProps.firstDayOfWeek !== firstDayOfWeek) {
-      this.props.fetchCalendar({ time, view });
-    }
-
-    if (prevProps.isRefreshingMovie && !isRefreshingMovie) {
-      this.props.fetchCalendar({ time, view });
-    }
-  }
-
-  componentWillUnmount() {
-    unregisterPagePopulator(this.repopulate);
-    this.props.clearCalendar();
-    this.props.clearQueueDetails();
-    this.props.clearMovieFiles();
-    this.clearUpdateTimeout();
-  }
-
-  //
-  // Control
-
-  repopulate = () => {
-    const {
-      time,
-      view
-    } = this.props;
-
-    this.props.fetchQueueDetails({ time, view });
-    this.props.fetchCalendar({ time, view });
-  };
-
-  scheduleUpdate = () => {
-    this.clearUpdateTimeout();
-
-    this.updateTimeoutId = setTimeout(this.updateCalendar, UPDATE_DELAY);
-  };
-
-  clearUpdateTimeout = () => {
-    if (this.updateTimeoutId) {
-      clearTimeout(this.updateTimeoutId);
-    }
-  };
-
-  updateCalendar = () => {
-    this.props.gotoCalendarToday();
-    this.scheduleUpdate();
-  };
-
-  //
-  // Listeners
-
-  onCalendarViewChange = (view) => {
-    this.props.setCalendarView({ view });
-  };
-
-  onTodayPress = () => {
-    this.props.gotoCalendarToday();
-  };
-
-  onPreviousPress = () => {
-    this.props.gotoCalendarPreviousRange();
-  };
-
-  onNextPress = () => {
-    this.props.gotoCalendarNextRange();
-  };
-
-  //
-  // Render
-
-  render() {
-    return (
-      <Calendar
-        {...this.props}
-        onCalendarViewChange={this.onCalendarViewChange}
-        onTodayPress={this.onTodayPress}
-        onPreviousPress={this.onPreviousPress}
-        onNextPress={this.onNextPress}
-      />
-    );
-  }
-}
-
-CalendarConnector.propTypes = {
-  useCurrentPage: PropTypes.bool.isRequired,
-  time: PropTypes.string,
-  view: PropTypes.string.isRequired,
-  firstDayOfWeek: PropTypes.number.isRequired,
-  items: PropTypes.arrayOf(PropTypes.object).isRequired,
-  isRefreshingMovie: PropTypes.bool.isRequired,
-  setCalendarView: PropTypes.func.isRequired,
-  gotoCalendarToday: PropTypes.func.isRequired,
-  gotoCalendarPreviousRange: PropTypes.func.isRequired,
-  gotoCalendarNextRange: PropTypes.func.isRequired,
-  clearCalendar: PropTypes.func.isRequired,
-  fetchCalendar: PropTypes.func.isRequired,
-  fetchMovieFiles: PropTypes.func.isRequired,
-  clearMovieFiles: PropTypes.func.isRequired,
-  fetchQueueDetails: PropTypes.func.isRequired,
-  clearQueueDetails: PropTypes.func.isRequired
-};
-
-export default connect(createMapStateToProps, mapDispatchToProps)(CalendarConnector);

frontend/src/Calendar/CalendarPage.js

@@ -1,224 +0,0 @@
-import PropTypes from 'prop-types';
-import React, { Component } from 'react';
-import LoadingIndicator from 'Components/Loading/LoadingIndicator';
-import Measure from 'Components/Measure';
-import FilterMenu from 'Components/Menu/FilterMenu';
-import PageContent from 'Components/Page/PageContent';
-import PageContentBody from 'Components/Page/PageContentBody';
-import PageToolbar from 'Components/Page/Toolbar/PageToolbar';
-import PageToolbarButton from 'Components/Page/Toolbar/PageToolbarButton';
-import PageToolbarSection from 'Components/Page/Toolbar/PageToolbarSection';
-import PageToolbarSeparator from 'Components/Page/Toolbar/PageToolbarSeparator';
-import { align, icons } from 'Helpers/Props';
-import NoMovie from 'Movie/NoMovie';
-import getErrorMessage from 'Utilities/Object/getErrorMessage';
-import translate from 'Utilities/String/translate';
-import CalendarConnector from './CalendarConnector';
-import CalendarFilterModal from './CalendarFilterModal';
-import CalendarLinkModal from './iCal/CalendarLinkModal';
-import LegendConnector from './Legend/LegendConnector';
-import CalendarOptionsModal from './Options/CalendarOptionsModal';
-import styles from './CalendarPage.css';
-
-const MINIMUM_DAY_WIDTH = 120;
-
-class CalendarPage extends Component {
-
-  //
-  // Lifecycle
-
-  constructor(props, context) {
-    super(props, context);
-
-    this.state = {
-      isCalendarLinkModalOpen: false,
-      isOptionsModalOpen: false,
-      width: 0
-    };
-  }
-
-  //
-  // Listeners
-
-  onMeasure = ({ width }) => {
-    this.setState({ width });
-    const days = Math.max(3, Math.min(7, Math.floor(width / MINIMUM_DAY_WIDTH)));
-
-    this.props.onDaysCountChange(days);
-  };
-
-  onGetCalendarLinkPress = () => {
-    this.setState({ isCalendarLinkModalOpen: true });
-  };
-
-  onGetCalendarLinkModalClose = () => {
-    this.setState({ isCalendarLinkModalOpen: false });
-  };
-
-  onOptionsPress = () => {
-    this.setState({ isOptionsModalOpen: true });
-  };
-
-  onOptionsModalClose = () => {
-    this.setState({ isOptionsModalOpen: false });
-  };
-
-  onSearchMissingPress = () => {
-    const {
-      missingMovieIds,
-      onSearchMissingPress
-    } = this.props;
-
-    onSearchMissingPress(missingMovieIds);
-  };
-
-  //
-  // Render
-
-  render() {
-    const {
-      selectedFilterKey,
-      filters,
-      hasMovie,
-      movieError,
-      movieIsFetching,
-      movieIsPopulated,
-      missingMovieIds,
-      customFilters,
-      isRssSyncExecuting,
-      isSearchingForMissing,
-      useCurrentPage,
-      onRssSyncPress,
-      onFilterSelect
-    } = this.props;
-
-    const {
-      isCalendarLinkModalOpen,
-      isOptionsModalOpen
-    } = this.state;
-
-    const isMeasured = this.state.width > 0;
-
-    return (
-      <PageContent title={translate('Calendar')}>
-        <PageToolbar>
-          <PageToolbarSection>
-            <PageToolbarButton
-              label={translate('ICalLink')}
-              iconName={icons.CALENDAR}
-              onPress={this.onGetCalendarLinkPress}
-            />
-
-            <PageToolbarSeparator />
-
-            <PageToolbarButton
-              label={translate('RssSync')}
-              iconName={icons.RSS}
-              isSpinning={isRssSyncExecuting}
-              onPress={onRssSyncPress}
-            />
-
-            <PageToolbarButton
-              label={translate('SearchForMissing')}
-              iconName={icons.SEARCH}
-              isDisabled={!missingMovieIds.length}
-              isSpinning={isSearchingForMissing}
-              onPress={this.onSearchMissingPress}
-            />
-          </PageToolbarSection>
-
-          <PageToolbarSection alignContent={align.RIGHT}>
-            <PageToolbarButton
-              label={translate('Options')}
-              iconName={icons.POSTER}
-              onPress={this.onOptionsPress}
-            />
-
-            <FilterMenu
-              alignMenu={align.RIGHT}
-              isDisabled={!hasMovie}
-              selectedFilterKey={selectedFilterKey}
-              filters={filters}
-              customFilters={customFilters}
-              filterModalConnectorComponent={CalendarFilterModal}
-              onFilterSelect={onFilterSelect}
-            />
-          </PageToolbarSection>
-        </PageToolbar>
-
-        <PageContentBody
-          className={styles.calendarPageBody}
-          innerClassName={styles.calendarInnerPageBody}
-        >
-          {
-            movieIsFetching && !movieIsPopulated &&
-              <LoadingIndicator />
-          }
-
-          {
-            movieError &&
-              <div className={styles.errorMessage}>
-                {getErrorMessage(movieError, 'Failed to load movies from API')}
-              </div>
-          }
-
-          {
-            !movieError && movieIsPopulated && hasMovie &&
-              <Measure
-                whitelist={['width']}
-                onMeasure={this.onMeasure}
-              >
-                {
-                  isMeasured ?
-                    <CalendarConnector
-                      useCurrentPage={useCurrentPage}
-                    /> :
-                    <div />
-                }
-              </Measure>
-          }
-
-          {
-            !movieError && movieIsPopulated && !hasMovie &&
-              <NoMovie totalItems={0} />
-          }
-
-          {
-            hasMovie && !movieError &&
-              <LegendConnector />
-          }
-        </PageContentBody>
-
-        <CalendarLinkModal
-          isOpen={isCalendarLinkModalOpen}
-          onModalClose={this.onGetCalendarLinkModalClose}
-        />
-
-        <CalendarOptionsModal
-          isOpen={isOptionsModalOpen}
-          onModalClose={this.onOptionsModalClose}
-        />
-      </PageContent>
-    );
-  }
-}
-
-CalendarPage.propTypes = {
-  selectedFilterKey: PropTypes.string.isRequired,
-  filters: PropTypes.arrayOf(PropTypes.object).isRequired,
-  hasMovie: PropTypes.bool.isRequired,
-  movieError: PropTypes.object,
-  movieIsFetching: PropTypes.bool.isRequired,
-  movieIsPopulated: PropTypes.bool.isRequired,
-  missingMovieIds: PropTypes.arrayOf(PropTypes.number).isRequired,
-  customFilters: PropTypes.arrayOf(PropTypes.object).isRequired,
-  isRssSyncExecuting: PropTypes.bool.isRequired,
-  isSearchingForMissing: PropTypes.bool.isRequired,
-  useCurrentPage: PropTypes.bool.isRequired,
-  onSearchMissingPress: PropTypes.func.isRequired,
-  onDaysCountChange: PropTypes.func.isRequired,
-  onRssSyncPress: PropTypes.func.isRequired,
-  onFilterSelect: PropTypes.func.isRequired
-};
-
-export default CalendarPage;

frontend/src/Calendar/CalendarPage.tsx

@@ -0,0 +1,224 @@
+import moment from 'moment';
+import React, { useCallback, useEffect, useState } from 'react';
+import { useDispatch, useSelector } from 'react-redux';
+import { createSelector } from 'reselect';
+import AppState from 'App/State/AppState';
+import * as commandNames from 'Commands/commandNames';
+import FilterMenu from 'Components/Menu/FilterMenu';
+import PageContent from 'Components/Page/PageContent';
+import PageContentBody from 'Components/Page/PageContentBody';
+import PageToolbar from 'Components/Page/Toolbar/PageToolbar';
+import PageToolbarButton from 'Components/Page/Toolbar/PageToolbarButton';
+import PageToolbarSection from 'Components/Page/Toolbar/PageToolbarSection';
+import PageToolbarSeparator from 'Components/Page/Toolbar/PageToolbarSeparator';
+import useMeasure from 'Helpers/Hooks/useMeasure';
+import { align, icons } from 'Helpers/Props';
+import NoMovie from 'Movie/NoMovie';
+import {
+  searchMissing,
+  setCalendarDaysCount,
+  setCalendarFilter,
+} from 'Store/Actions/calendarActions';
+import { executeCommand } from 'Store/Actions/commandActions';
+import { createCustomFiltersSelector } from 'Store/Selectors/createClientSideCollectionSelector';
+import createCommandExecutingSelector from 'Store/Selectors/createCommandExecutingSelector';
+import createCommandsSelector from 'Store/Selectors/createCommandsSelector';
+import createMovieCountSelector from 'Store/Selectors/createMovieCountSelector';
+import { isCommandExecuting } from 'Utilities/Command';
+import isBefore from 'Utilities/Date/isBefore';
+import translate from 'Utilities/String/translate';
+import Calendar from './Calendar';
+import CalendarFilterModal from './CalendarFilterModal';
+import CalendarLinkModal from './iCal/CalendarLinkModal';
+import Legend from './Legend/Legend';
+import CalendarOptionsModal from './Options/CalendarOptionsModal';
+import styles from './CalendarPage.css';
+
+const MINIMUM_DAY_WIDTH = 120;
+
+function createMissingMovieIdsSelector() {
+  return createSelector(
+    (state: AppState) => state.calendar.start,
+    (state: AppState) => state.calendar.end,
+    (state: AppState) => state.calendar.items,
+    (state: AppState) => state.queue.details.items,
+    (start, end, movies, queueDetails) => {
+      return movies.reduce<number[]>((acc, movie) => {
+        const { inCinemas } = movie;
+
+        if (
+          !movie.movieFileId &&
+          inCinemas &&
+          moment(inCinemas).isAfter(start) &&
+          moment(inCinemas).isBefore(end) &&
+          isBefore(inCinemas) &&
+          !queueDetails.some(
+            (details) => !!details.movie && details.movie.id === movie.id
+          )
+        ) {
+          acc.push(movie.id);
+        }
+
+        return acc;
+      }, []);
+    }
+  );
+}
+
+function createIsSearchingSelector() {
+  return createSelector(
+    (state: AppState) => state.calendar.searchMissingCommandId,
+    createCommandsSelector(),
+    (searchMissingCommandId, commands) => {
+      if (searchMissingCommandId == null) {
+        return false;
+      }
+
+      return isCommandExecuting(
+        commands.find((command) => {
+          return command.id === searchMissingCommandId;
+        })
+      );
+    }
+  );
+}
+
+function CalendarPage() {
+  const dispatch = useDispatch();
+
+  const { selectedFilterKey, filters } = useSelector(
+    (state: AppState) => state.calendar
+  );
+  const missingMovieIds = useSelector(createMissingMovieIdsSelector());
+  const isSearchingForMissing = useSelector(createIsSearchingSelector());
+  const isRssSyncExecuting = useSelector(
+    createCommandExecutingSelector(commandNames.RSS_SYNC)
+  );
+  const customFilters = useSelector(createCustomFiltersSelector('calendar'));
+  const hasMovies = !!useSelector(createMovieCountSelector());
+
+  const [pageContentRef, { width }] = useMeasure();
+  const [isCalendarLinkModalOpen, setIsCalendarLinkModalOpen] = useState(false);
+  const [isOptionsModalOpen, setIsOptionsModalOpen] = useState(false);
+
+  const isMeasured = width > 0;
+  const PageComponent = hasMovies ? Calendar : NoMovie;
+
+  const handleGetCalendarLinkPress = useCallback(() => {
+    setIsCalendarLinkModalOpen(true);
+  }, []);
+
+  const handleGetCalendarLinkModalClose = useCallback(() => {
+    setIsCalendarLinkModalOpen(false);
+  }, []);
+
+  const handleOptionsPress = useCallback(() => {
+    setIsOptionsModalOpen(true);
+  }, []);
+
+  const handleOptionsModalClose = useCallback(() => {
+    setIsOptionsModalOpen(false);
+  }, []);
+
+  const handleRssSyncPress = useCallback(() => {
+    dispatch(
+      executeCommand({
+        name: commandNames.RSS_SYNC,
+      })
+    );
+  }, [dispatch]);
+
+  const handleSearchMissingPress = useCallback(() => {
+    dispatch(searchMissing({ movieIds: missingMovieIds }));
+  }, [missingMovieIds, dispatch]);
+
+  const handleFilterSelect = useCallback(
+    (key: string | number) => {
+      dispatch(setCalendarFilter({ selectedFilterKey: key }));
+    },
+    [dispatch]
+  );
+
+  useEffect(() => {
+    if (width === 0) {
+      return;
+    }
+
+    const dayCount = Math.max(
+      3,
+      Math.min(7, Math.floor(width / MINIMUM_DAY_WIDTH))
+    );
+
+    dispatch(setCalendarDaysCount({ dayCount }));
+  }, [width, dispatch]);
+
+  return (
+    <PageContent title={translate('Calendar')}>
+      <PageToolbar>
+        <PageToolbarSection>
+          <PageToolbarButton
+            label={translate('ICalLink')}
+            iconName={icons.CALENDAR}
+            onPress={handleGetCalendarLinkPress}
+          />
+
+          <PageToolbarSeparator />
+
+          <PageToolbarButton
+            label={translate('RssSync')}
+            iconName={icons.RSS}
+            isSpinning={isRssSyncExecuting}
+            onPress={handleRssSyncPress}
+          />
+
+          <PageToolbarButton
+            label={translate('SearchForMissing')}
+            iconName={icons.SEARCH}
+            isDisabled={!missingMovieIds.length}
+            isSpinning={isSearchingForMissing}
+            onPress={handleSearchMissingPress}
+          />
+        </PageToolbarSection>
+
+        <PageToolbarSection alignContent={align.RIGHT}>
+          <PageToolbarButton
+            label={translate('Options')}
+            iconName={icons.POSTER}
+            onPress={handleOptionsPress}
+          />
+
+          <FilterMenu
+            alignMenu={align.RIGHT}
+            isDisabled={!hasMovies}
+            selectedFilterKey={selectedFilterKey}
+            filters={filters}
+            customFilters={customFilters}
+            filterModalConnectorComponent={CalendarFilterModal}
+            onFilterSelect={handleFilterSelect}
+          />
+        </PageToolbarSection>
+      </PageToolbar>
+
+      <PageContentBody
+        ref={pageContentRef}
+        className={styles.calendarPageBody}
+        innerClassName={styles.calendarInnerPageBody}
+      >
+        {isMeasured ? <PageComponent totalItems={0} /> : <div />}
+        {hasMovies && <Legend />}
+      </PageContentBody>
+
+      <CalendarLinkModal
+        isOpen={isCalendarLinkModalOpen}
+        onModalClose={handleGetCalendarLinkModalClose}
+      />
+
+      <CalendarOptionsModal
+        isOpen={isOptionsModalOpen}
+        onModalClose={handleOptionsModalClose}
+      />
+    </PageContent>
+  );
+}
+
+export default CalendarPage;

frontend/src/Calendar/CalendarPageConnector.js

@@ -1,120 +0,0 @@
-import moment from 'moment';
-import { connect } from 'react-redux';
-import { createSelector } from 'reselect';
-import * as commandNames from 'Commands/commandNames';
-import withCurrentPage from 'Components/withCurrentPage';
-import { searchMissing, setCalendarDaysCount, setCalendarFilter } from 'Store/Actions/calendarActions';
-import { executeCommand } from 'Store/Actions/commandActions';
-import { createCustomFiltersSelector } from 'Store/Selectors/createClientSideCollectionSelector';
-import createCommandExecutingSelector from 'Store/Selectors/createCommandExecutingSelector';
-import createCommandsSelector from 'Store/Selectors/createCommandsSelector';
-import createMovieCountSelector from 'Store/Selectors/createMovieCountSelector';
-import createUISettingsSelector from 'Store/Selectors/createUISettingsSelector';
-import { isCommandExecuting } from 'Utilities/Command';
-import isBefore from 'Utilities/Date/isBefore';
-import CalendarPage from './CalendarPage';
-
-function createMissingMovieIdsSelector() {
-  return createSelector(
-    (state) => state.calendar.start,
-    (state) => state.calendar.end,
-    (state) => state.calendar.items,
-    (state) => state.queue.details.items,
-    (start, end, movies, queueDetails) => {
-      return movies.reduce((acc, movie) => {
-        const inCinemas = movie.inCinemas;
-
-        if (
-          !movie.hasFile &&
-          moment(inCinemas).isAfter(start) &&
-          moment(inCinemas).isBefore(end) &&
-          isBefore(movie.inCinemas) &&
-          !queueDetails.some((details) => details.movieId === movie.id)
-        ) {
-          acc.push(movie.id);
-        }
-
-        return acc;
-      }, []);
-    }
-  );
-}
-
-function createIsSearchingSelector() {
-  return createSelector(
-    (state) => state.calendar.searchMissingCommandId,
-    createCommandsSelector(),
-    (searchMissingCommandId, commands) => {
-      if (searchMissingCommandId == null) {
-        return false;
-      }
-
-      return isCommandExecuting(commands.find((command) => {
-        return command.id === searchMissingCommandId;
-      }));
-    }
-  );
-}
-
-function createMapStateToProps() {
-  return createSelector(
-    (state) => state.calendar.selectedFilterKey,
-    (state) => state.calendar.filters,
-    createCustomFiltersSelector('calendar'),
-    createMovieCountSelector(),
-    createUISettingsSelector(),
-    createMissingMovieIdsSelector(),
-    createCommandExecutingSelector(commandNames.RSS_SYNC),
-    createIsSearchingSelector(),
-    (
-      selectedFilterKey,
-      filters,
-      customFilters,
-      movieCount,
-      uiSettings,
-      missingMovieIds,
-      isRssSyncExecuting,
-      isSearchingForMissing
-    ) => {
-      return {
-        selectedFilterKey,
-        filters,
-        customFilters,
-        colorImpairedMode: uiSettings.enableColorImpairedMode,
-        hasMovie: !!movieCount.count,
-        movieError: movieCount.error,
-        movieIsFetching: movieCount.isFetching,
-        movieIsPopulated: movieCount.isPopulated,
-        missingMovieIds,
-        isRssSyncExecuting,
-        isSearchingForMissing
-      };
-    }
-  );
-}
-
-function createMapDispatchToProps(dispatch, props) {
-  return {
-    onRssSyncPress() {
-      dispatch(executeCommand({
-        name: commandNames.RSS_SYNC
-      }));
-    },
-
-    onSearchMissingPress(movieIds) {
-      dispatch(searchMissing({ movieIds }));
-    },
-
-    onDaysCountChange(dayCount) {
-      dispatch(setCalendarDaysCount({ dayCount }));
-    },
-
-    onFilterSelect(selectedFilterKey) {
-      dispatch(setCalendarFilter({ selectedFilterKey }));
-    }
-  };
-}
-
-export default withCurrentPage(
-  connect(createMapStateToProps, createMapDispatchToProps)(CalendarPage)
-);

frontend/src/Calendar/Day/CalendarDay.tsx

@@ -1,23 +1,61 @@
 import classNames from 'classnames';
 import moment from 'moment';
 import React from 'react';
+import { useSelector } from 'react-redux';
+import { createSelector } from 'reselect';
+import AppState from 'App/State/AppState';
 import * as calendarViews from 'Calendar/calendarViews';
-import CalendarEventConnector from 'Calendar/Events/CalendarEventConnector';
-import CalendarEvent from 'typings/CalendarEvent';
+import CalendarEvent from 'Calendar/Events/CalendarEvent';
+import { CalendarEvent as CalendarEventModel } from 'typings/Calendar';
 import styles from './CalendarDay.css';
 
+function sort(items: CalendarEventModel[]) {
+  return items.sort((a, b) => {
+    const aDate = moment(a.inCinemas).unix();
+    const bDate = moment(b.inCinemas).unix();
+
+    return aDate - bDate;
+  });
+}
+
+function createCalendarEventsConnector(date: string) {
+  return createSelector(
+    (state: AppState) => state.calendar.items,
+    (state: AppState) => state.calendar.options,
+    (items, options) => {
+      const { showCinemaRelease, showDigitalRelease, showPhysicalRelease } =
+        options;
+      const momentDate = moment(date);
+
+      const filtered = items.filter(
+        ({ inCinemas, digitalRelease, physicalRelease }) => {
+          return (
+            (showCinemaRelease &&
+              inCinemas &&
+              momentDate.isSame(moment(inCinemas), 'day')) ||
+            (showDigitalRelease &&
+              digitalRelease &&
+              momentDate.isSame(moment(digitalRelease), 'day')) ||
+            (showPhysicalRelease &&
+              physicalRelease &&
+              momentDate.isSame(moment(physicalRelease), 'day'))
+          );
+        }
+      );
+
+      return sort(filtered);
+    }
+  );
+}
+
 interface CalendarDayProps {
   date: string;
-  time: string;
   isTodaysDate: boolean;
-  events: CalendarEvent[];
-  view: string;
-  onEventModalOpenToggle(...args: unknown[]): unknown;
 }
 
-function CalendarDay(props: CalendarDayProps) {
-  const { date, time, isTodaysDate, events, view, onEventModalOpenToggle } =
-    props;
+function CalendarDay({ date, isTodaysDate }: CalendarDayProps) {
+  const { time, view } = useSelector((state: AppState) => state.calendar);
+  const events = useSelector(createCalendarEventsConnector(date));
 
   const ref = React.useRef<HTMLDivElement>(null);
 
@@ -50,13 +88,7 @@ function CalendarDay(props: CalendarDayProps) {
       <div>
         {events.map((event) => {
           return (
-            <CalendarEventConnector
-              key={event.id}
-              {...event}
-              movieId={event.id}
-              date={date as string}
-              onEventModalOpenToggle={onEventModalOpenToggle}
-            />
+            <CalendarEvent key={event.id} {...event} date={date as string} />
           );
         })}
       </div>

frontend/src/Calendar/Day/CalendarDayConnector.js

@@ -1,67 +0,0 @@
-import _ from 'lodash';
-import moment from 'moment';
-import PropTypes from 'prop-types';
-import React, { Component } from 'react';
-import { connect } from 'react-redux';
-import { createSelector } from 'reselect';
-import CalendarDay from './CalendarDay';
-
-function sort(items) {
-  return _.sortBy(items, (item) => {
-    if (item.isGroup) {
-      return moment(item.events[0].inCinemas).unix();
-    }
-
-    return moment(item.inCinemas).unix();
-  });
-}
-
-function createCalendarEventsConnector() {
-  return createSelector(
-    (state, { date }) => date,
-    (state) => state.calendar.items,
-    (date, items) => {
-      const filtered = _.filter(items, (item) => {
-        return (item.inCinemas && moment(date).isSame(moment(item.inCinemas), 'day')) ||
-          (item.physicalRelease && moment(date).isSame(moment(item.physicalRelease), 'day')) ||
-          (item.digitalRelease && moment(date).isSame(moment(item.digitalRelease), 'day'));
-      });
-
-      return sort(filtered);
-    }
-  );
-}
-
-function createMapStateToProps() {
-  return createSelector(
-    (state) => state.calendar,
-    createCalendarEventsConnector(),
-    (calendar, events) => {
-      return {
-        time: calendar.time,
-        view: calendar.view,
-        events
-      };
-    }
-  );
-}
-
-class CalendarDayConnector extends Component {
-
-  //
-  // Render
-
-  render() {
-    return (
-      <CalendarDay
-        {...this.props}
-      />
-    );
-  }
-}
-
-CalendarDayConnector.propTypes = {
-  date: PropTypes.string.isRequired
-};
-
-export default connect(createMapStateToProps)(CalendarDayConnector);

frontend/src/Calendar/Day/CalendarDays.js

@@ -1,164 +0,0 @@
-import classNames from 'classnames';
-import moment from 'moment';
-import PropTypes from 'prop-types';
-import React, { Component } from 'react';
-import * as calendarViews from 'Calendar/calendarViews';
-import isToday from 'Utilities/Date/isToday';
-import CalendarDayConnector from './CalendarDayConnector';
-import styles from './CalendarDays.css';
-
-class CalendarDays extends Component {
-
-  //
-  // Lifecycle
-
-  constructor(props, context) {
-    super(props, context);
-
-    this._touchStart = null;
-
-    this.state = {
-      todaysDate: moment().startOf('day').toISOString(),
-      isEventModalOpen: false
-    };
-
-    this.updateTimeoutId = null;
-  }
-
-  // Lifecycle
-
-  componentDidMount() {
-    const view = this.props.view;
-
-    if (view === calendarViews.MONTH) {
-      this.scheduleUpdate();
-    }
-
-    window.addEventListener('touchstart', this.onTouchStart);
-    window.addEventListener('touchend', this.onTouchEnd);
-    window.addEventListener('touchcancel', this.onTouchCancel);
-    window.addEventListener('touchmove', this.onTouchMove);
-  }
-
-  componentWillUnmount() {
-    this.clearUpdateTimeout();
-
-    window.removeEventListener('touchstart', this.onTouchStart);
-    window.removeEventListener('touchend', this.onTouchEnd);
-    window.removeEventListener('touchcancel', this.onTouchCancel);
-    window.removeEventListener('touchmove', this.onTouchMove);
-  }
-
-  //
-  // Control
-
-  scheduleUpdate = () => {
-    this.clearUpdateTimeout();
-    const todaysDate = moment().startOf('day');
-    const diff = moment().diff(todaysDate.clone().add(1, 'day'));
-
-    this.setState({ todaysDate: todaysDate.toISOString() });
-
-    this.updateTimeoutId = setTimeout(this.scheduleUpdate, diff);
-  };
-
-  clearUpdateTimeout = () => {
-    if (this.updateTimeoutId) {
-      clearTimeout(this.updateTimeoutId);
-    }
-  };
-
-  //
-  // Listeners
-
-  onEventModalOpenToggle = (isEventModalOpen) => {
-    this.setState({ isEventModalOpen });
-  };
-
-  onTouchStart = (event) => {
-    const touches = event.touches;
-    const touchStart = touches[0].pageX;
-
-    if (touches.length !== 1) {
-      return;
-    }
-
-    if (
-      touchStart < 50 ||
-      this.props.isSidebarVisible ||
-      this.state.isEventModalOpen
-    ) {
-      return;
-    }
-
-    this._touchStart = touchStart;
-  };
-
-  onTouchEnd = (event) => {
-    const touches = event.changedTouches;
-    const currentTouch = touches[0].pageX;
-
-    if (!this._touchStart) {
-      return;
-    }
-
-    if (currentTouch > this._touchStart && currentTouch - this._touchStart > 100) {
-      this.props.onNavigatePrevious();
-    } else if (currentTouch < this._touchStart && this._touchStart - currentTouch > 100) {
-      this.props.onNavigateNext();
-    }
-
-    this._touchStart = null;
-  };
-
-  onTouchCancel = (event) => {
-    this._touchStart = null;
-  };
-
-  onTouchMove = (event) => {
-    if (!this._touchStart) {
-      return;
-    }
-  };
-
-  //
-  // Render
-
-  render() {
-    const {
-      dates,
-      view
-    } = this.props;
-
-    return (
-      <div className={classNames(
-        styles.days,
-        styles[view]
-      )}
-      >
-        {
-          dates.map((date) => {
-            return (
-              <CalendarDayConnector
-                key={date}
-                date={date}
-                isTodaysDate={isToday(date)}
-                onEventModalOpenToggle={this.onEventModalOpenToggle}
-              />
-            );
-          })
-        }
-      </div>
-    );
-  }
-}
-
-CalendarDays.propTypes = {
-  dates: PropTypes.arrayOf(PropTypes.string).isRequired,
-  view: PropTypes.string.isRequired,
-  isSidebarVisible: PropTypes.bool.isRequired,
-  onNavigatePrevious: PropTypes.func.isRequired,
-  onNavigateNext: PropTypes.func.isRequired
-};
-
-export default CalendarDays;

frontend/src/Calendar/Day/CalendarDays.tsx

@@ -0,0 +1,129 @@
+import classNames from 'classnames';
+import moment from 'moment';
+import React, { useCallback, useEffect, useRef, useState } from 'react';
+import { useDispatch, useSelector } from 'react-redux';
+import AppState from 'App/State/AppState';
+import * as calendarViews from 'Calendar/calendarViews';
+import {
+  gotoCalendarNextRange,
+  gotoCalendarPreviousRange,
+} from 'Store/Actions/calendarActions';
+import CalendarDay from './CalendarDay';
+import styles from './CalendarDays.css';
+
+function CalendarDays() {
+  const dispatch = useDispatch();
+  const { dates, view } = useSelector((state: AppState) => state.calendar);
+  const isSidebarVisible = useSelector(
+    (state: AppState) => state.app.isSidebarVisible
+  );
+
+  const updateTimeout = useRef<ReturnType<typeof setTimeout>>();
+  const touchStart = useRef<number | null>(null);
+  const [todaysDate, setTodaysDate] = useState(
+    moment().startOf('day').toISOString()
+  );
+
+  const scheduleUpdate = useCallback(() => {
+    clearTimeout(updateTimeout.current);
+
+    const todaysDate = moment().startOf('day');
+    const diff = moment().diff(todaysDate.clone().add(1, 'day'));
+
+    setTodaysDate(todaysDate.toISOString());
+
+    updateTimeout.current = setTimeout(scheduleUpdate, diff);
+  }, []);
+
+  const handleTouchStart = useCallback(
+    (event: TouchEvent) => {
+      const touches = event.touches;
+      const currentTouch = touches[0].pageX;
+
+      if (touches.length !== 1) {
+        return;
+      }
+
+      if (currentTouch < 50 || isSidebarVisible) {
+        return;
+      }
+
+      touchStart.current = currentTouch;
+    },
+    [isSidebarVisible]
+  );
+
+  const handleTouchEnd = useCallback(
+    (event: TouchEvent) => {
+      const touches = event.changedTouches;
+      const currentTouch = touches[0].pageX;
+
+      if (!touchStart.current) {
+        return;
+      }
+
+      if (
+        currentTouch > touchStart.current &&
+        currentTouch - touchStart.current > 100
+      ) {
+        dispatch(gotoCalendarPreviousRange());
+      } else if (
+        currentTouch < touchStart.current &&
+        touchStart.current - currentTouch > 100
+      ) {
+        dispatch(gotoCalendarNextRange());
+      }
+
+      touchStart.current = null;
+    },
+    [dispatch]
+  );
+
+  const handleTouchCancel = useCallback(() => {
+    touchStart.current = null;
+  }, []);
+
+  const handleTouchMove = useCallback(() => {
+    if (!touchStart.current) {
+      return;
+    }
+  }, []);
+
+  useEffect(() => {
+    if (view === calendarViews.MONTH) {
+      scheduleUpdate();
+    }
+  }, [view, scheduleUpdate]);
+
+  useEffect(() => {
+    window.addEventListener('touchstart', handleTouchStart);
+    window.addEventListener('touchend', handleTouchEnd);
+    window.addEventListener('touchcancel', handleTouchCancel);
+    window.addEventListener('touchmove', handleTouchMove);
+
+    return () => {
+      window.removeEventListener('touchstart', handleTouchStart);
+      window.removeEventListener('touchend', handleTouchEnd);
+      window.removeEventListener('touchcancel', handleTouchCancel);
+      window.removeEventListener('touchmove', handleTouchMove);
+    };
+  }, [handleTouchStart, handleTouchEnd, handleTouchCancel, handleTouchMove]);
+
+  return (
+    <div
+      className={classNames(styles.days, styles[view as keyof typeof styles])}
+    >
+      {dates.map((date) => {
+        return (
+          <CalendarDay
+            key={date}
+            date={date}
+            isTodaysDate={date === todaysDate}
+          />
+        );
+      })}
+    </div>
+  );
+}
+
+export default CalendarDays;

frontend/src/Calendar/Day/CalendarDaysConnector.js

@@ -1,25 +0,0 @@
-import { connect } from 'react-redux';
-import { createSelector } from 'reselect';
-import { gotoCalendarNextRange, gotoCalendarPreviousRange } from 'Store/Actions/calendarActions';
-import CalendarDays from './CalendarDays';
-
-function createMapStateToProps() {
-  return createSelector(
-    (state) => state.calendar,
-    (state) => state.app.isSidebarVisible,
-    (calendar, isSidebarVisible) => {
-      return {
-        dates: calendar.dates,
-        view: calendar.view,
-        isSidebarVisible
-      };
-    }
-  );
-}
-
-const mapDispatchToProps = {
-  onNavigatePrevious: gotoCalendarPreviousRange,
-  onNavigateNext: gotoCalendarNextRange
-};
-
-export default connect(createMapStateToProps, mapDispatchToProps)(CalendarDays);

frontend/src/Calendar/Day/DayOfWeek.js

@@ -1,56 +0,0 @@
-import classNames from 'classnames';
-import moment from 'moment';
-import PropTypes from 'prop-types';
-import React, { Component } from 'react';
-import * as calendarViews from 'Calendar/calendarViews';
-import getRelativeDate from 'Utilities/Date/getRelativeDate';
-import styles from './DayOfWeek.css';
-
-class DayOfWeek extends Component {
-
-  //
-  // Render
-
-  render() {
-    const {
-      date,
-      view,
-      isTodaysDate,
-      calendarWeekColumnHeader,
-      shortDateFormat,
-      showRelativeDates
-    } = this.props;
-
-    const highlightToday = view !== calendarViews.MONTH && isTodaysDate;
-    const momentDate = moment(date);
-    let formatedDate = momentDate.format('dddd');
-
-    if (view === calendarViews.WEEK) {
-      formatedDate = momentDate.format(calendarWeekColumnHeader);
-    } else if (view === calendarViews.FORECAST) {
-      formatedDate = getRelativeDate({ date, shortDateFormat, showRelativeDates });
-    }
-
-    return (
-      <div className={classNames(
-        styles.dayOfWeek,
-        view === calendarViews.DAY && styles.isSingleDay,
-        highlightToday && styles.isToday
-      )}
-      >
-        {formatedDate}
-      </div>
-    );
-  }
-}
-
-DayOfWeek.propTypes = {
-  date: PropTypes.string.isRequired,
-  view: PropTypes.string.isRequired,
-  isTodaysDate: PropTypes.bool.isRequired,
-  calendarWeekColumnHeader: PropTypes.string.isRequired,
-  shortDateFormat: PropTypes.string.isRequired,
-  showRelativeDates: PropTypes.bool.isRequired
-};
-
-export default DayOfWeek;

frontend/src/Calendar/Day/DayOfWeek.tsx

@@ -0,0 +1,54 @@
+import classNames from 'classnames';
+import moment from 'moment';
+import React from 'react';
+import * as calendarViews from 'Calendar/calendarViews';
+import getRelativeDate from 'Utilities/Date/getRelativeDate';
+import styles from './DayOfWeek.css';
+
+interface DayOfWeekProps {
+  date: string;
+  view: string;
+  isTodaysDate: boolean;
+  calendarWeekColumnHeader: string;
+  shortDateFormat: string;
+  showRelativeDates: boolean;
+}
+
+function DayOfWeek(props: DayOfWeekProps) {
+  const {
+    date,
+    view,
+    isTodaysDate,
+    calendarWeekColumnHeader,
+    shortDateFormat,
+    showRelativeDates,
+  } = props;
+
+  const highlightToday = view !== calendarViews.MONTH && isTodaysDate;
+  const momentDate = moment(date);
+  let formatedDate = momentDate.format('dddd');
+
+  if (view === calendarViews.WEEK) {
+    formatedDate = momentDate.format(calendarWeekColumnHeader);
+  } else if (view === calendarViews.FORECAST) {
+    formatedDate = getRelativeDate({
+      date,
+      shortDateFormat,
+      showRelativeDates,
+    });
+  }
+
+  return (
+    <div
+      className={classNames(
+        styles.dayOfWeek,
+        view === calendarViews.DAY && styles.isSingleDay,
+        highlightToday && styles.isToday
+      )}
+    >
+      {formatedDate}
+    </div>
+  );
+}
+
+export default DayOfWeek;

frontend/src/Calendar/Day/DaysOfWeek.js

@@ -1,97 +0,0 @@
-import moment from 'moment';
-import PropTypes from 'prop-types';
-import React, { Component } from 'react';
-import * as calendarViews from 'Calendar/calendarViews';
-import DayOfWeek from './DayOfWeek';
-import styles from './DaysOfWeek.css';
-
-class DaysOfWeek extends Component {
-
-  //
-  // Lifecycle
-
-  constructor(props, context) {
-    super(props, context);
-
-    this.state = {
-      todaysDate: moment().startOf('day').toISOString()
-    };
-
-    this.updateTimeoutId = null;
-  }
-
-  // Lifecycle
-
-  componentDidMount() {
-    const view = this.props.view;
-
-    if (view !== calendarViews.AGENDA || view !== calendarViews.MONTH) {
-      this.scheduleUpdate();
-    }
-  }
-
-  componentWillUnmount() {
-    this.clearUpdateTimeout();
-  }
-
-  //
-  // Control
-
-  scheduleUpdate = () => {
-    this.clearUpdateTimeout();
-    const todaysDate = moment().startOf('day');
-    const diff = todaysDate.clone().add(1, 'day').diff(moment());
-
-    this.setState({
-      todaysDate: todaysDate.toISOString()
-    });
-
-    this.updateTimeoutId = setTimeout(this.scheduleUpdate, diff);
-  };
-
-  clearUpdateTimeout = () => {
-    if (this.updateTimeoutId) {
-      clearTimeout(this.updateTimeoutId);
-    }
-  };
-
-  //
-  // Render
-
-  render() {
-    const {
-      dates,
-      view,
-      ...otherProps
-    } = this.props;
-
-    if (view === calendarViews.AGENDA) {
-      return null;
-    }
-
-    return (
-      <div className={styles.daysOfWeek}>
-        {
-          dates.map((date) => {
-            return (
-              <DayOfWeek
-                key={date}
-                date={date}
-                view={view}
-                isTodaysDate={date === this.state.todaysDate}
-                {...otherProps}
-              />
-            );
-          })
-        }
-      </div>
-    );
-  }
-}
-
-DaysOfWeek.propTypes = {
-  dates: PropTypes.arrayOf(PropTypes.string),
-  view: PropTypes.string.isRequired
-};
-
-export default DaysOfWeek;

frontend/src/Calendar/Day/DaysOfWeek.tsx

@@ -0,0 +1,60 @@
+import moment from 'moment';
+import React, { useCallback, useEffect, useRef, useState } from 'react';
+import { useSelector } from 'react-redux';
+import AppState from 'App/State/AppState';
+import * as calendarViews from 'Calendar/calendarViews';
+import createUISettingsSelector from 'Store/Selectors/createUISettingsSelector';
+import DayOfWeek from './DayOfWeek';
+import styles from './DaysOfWeek.css';
+
+function DaysOfWeek() {
+  const { dates, view } = useSelector((state: AppState) => state.calendar);
+  const { calendarWeekColumnHeader, shortDateFormat, showRelativeDates } =
+    useSelector(createUISettingsSelector());
+
+  const updateTimeout = useRef<ReturnType<typeof setTimeout>>();
+  const [todaysDate, setTodaysDate] = useState(
+    moment().startOf('day').toISOString()
+  );
+
+  const scheduleUpdate = useCallback(() => {
+    clearTimeout(updateTimeout.current);
+
+    const todaysDate = moment().startOf('day');
+    const diff = moment().diff(todaysDate.clone().add(1, 'day'));
+
+    setTodaysDate(todaysDate.toISOString());
+
+    updateTimeout.current = setTimeout(scheduleUpdate, diff);
+  }, []);
+
+  useEffect(() => {
+    if (view !== calendarViews.AGENDA && view !== calendarViews.MONTH) {
+      scheduleUpdate();
+    }
+  }, [view, scheduleUpdate]);
+
+  if (view === calendarViews.AGENDA) {
+    return null;
+  }
+
+  return (
+    <div className={styles.daysOfWeek}>
+      {dates.map((date) => {
+        return (
+          <DayOfWeek
+            key={date}
+            date={date}
+            view={view}
+            isTodaysDate={date === todaysDate}
+            calendarWeekColumnHeader={calendarWeekColumnHeader}
+            shortDateFormat={shortDateFormat}
+            showRelativeDates={showRelativeDates}
+          />
+        );
+      })}
+    </div>
+  );
+}
+
+export default DaysOfWeek;

frontend/src/Calendar/Day/DaysOfWeekConnector.js

@@ -1,22 +0,0 @@
-import { connect } from 'react-redux';
-import { createSelector } from 'reselect';
-import createUISettingsSelector from 'Store/Selectors/createUISettingsSelector';
-import DaysOfWeek from './DaysOfWeek';
-
-function createMapStateToProps() {
-  return createSelector(
-    (state) => state.calendar,
-    createUISettingsSelector(),
-    (calendar, UiSettings) => {
-      return {
-        dates: calendar.dates.slice(0, 7),
-        view: calendar.view,
-        calendarWeekColumnHeader: UiSettings.calendarWeekColumnHeader,
-        shortDateFormat: UiSettings.shortDateFormat,
-        showRelativeDates: UiSettings.showRelativeDates
-      };
-    }
-  );
-}
-
-export default connect(createMapStateToProps)(DaysOfWeek);

frontend/src/Calendar/Events/CalendarEvent.css

@@ -34,7 +34,8 @@ $fullColorGradient: rgba(244, 245, 246, 0.2);
 }
 
 .movieTitle,
-.genres {
+.genres,
+.eventType {
   @add-mixin truncate;
   flex: 1 0 1px;
   margin-right: 10px;

frontend/src/Calendar/Events/CalendarEvent.css.d.ts

@@ -4,6 +4,7 @@ interface CssExports {
   'continuing': string;
   'downloaded': string;
   'event': string;
+  'eventType': string;
   'genres': string;
   'info': string;
   'missingMonitored': string;

frontend/src/Calendar/Events/CalendarEvent.js

@@ -1,177 +0,0 @@
-import classNames from 'classnames';
-import moment from 'moment';
-import PropTypes from 'prop-types';
-import React, { Component } from 'react';
-import getStatusStyle from 'Calendar/getStatusStyle';
-import Icon from 'Components/Icon';
-import Link from 'Components/Link/Link';
-import { icons, kinds } from 'Helpers/Props';
-import translate from 'Utilities/String/translate';
-import CalendarEventQueueDetails from './CalendarEventQueueDetails';
-import styles from './CalendarEvent.css';
-
-class CalendarEvent extends Component {
-
-  //
-  // Render
-
-  render() {
-    const {
-      movieFile,
-      isAvailable,
-      inCinemas,
-      physicalRelease,
-      digitalRelease,
-      title,
-      titleSlug,
-      genres,
-      date,
-      monitored,
-      certification,
-      hasFile,
-      grabbed,
-      queueItem,
-      showMovieInformation,
-      showCutoffUnmetIcon,
-      fullColorEvents,
-      colorImpairedMode
-    } = this.props;
-
-    const isDownloading = !!(queueItem || grabbed);
-    const isMonitored = monitored;
-    const statusStyle = getStatusStyle(hasFile, isDownloading, isMonitored, isAvailable);
-    const joinedGenres = genres.slice(0, 2).join(', ');
-    const link = `/movie/${titleSlug}`;
-    const eventType = [];
-
-    if (inCinemas && moment(date).isSame(moment(inCinemas), 'day')) {
-      eventType.push('Cinemas');
-    }
-
-    if (physicalRelease && moment(date).isSame(moment(physicalRelease), 'day')) {
-      eventType.push('Physical');
-    }
-
-    if (digitalRelease && moment(date).isSame(moment(digitalRelease), 'day')) {
-      eventType.push('Digital');
-    }
-
-    return (
-      <div
-        className={classNames(
-          styles.event,
-          styles[statusStyle],
-          colorImpairedMode && 'colorImpaired',
-          fullColorEvents && 'fullColor'
-        )}
-      >
-        <Link
-          className={styles.underlay}
-          to={link}
-        />
-
-        <div className={styles.overlay} >
-          <div className={styles.info}>
-            <div className={styles.movieTitle}>
-              {title}
-            </div>
-
-            <div
-              className={classNames(
-                styles.statusContainer,
-                fullColorEvents && 'fullColor'
-              )}
-            >
-              {
-                queueItem ?
-                  <span className={styles.statusIcon}>
-                    <CalendarEventQueueDetails
-                      {...queueItem}
-                      fullColorEvents={fullColorEvents}
-                    />
-                  </span> :
-                  null
-              }
-
-              {
-                !queueItem && grabbed ?
-                  <Icon
-                    className={styles.statusIcon}
-                    name={icons.DOWNLOADING}
-                    title={translate('MovieIsDownloading')}
-                  /> :
-                  null
-              }
-
-              {
-                showCutoffUnmetIcon &&
-                !!movieFile &&
-                movieFile.qualityCutoffNotMet ?
-                  <Icon
-                    className={styles.statusIcon}
-                    name={icons.MOVIE_FILE}
-                    kind={kinds.WARNING}
-                    title={translate('QualityCutoffNotMet')}
-                  /> :
-                  null
-              }
-            </div>
-          </div>
-
-          {
-            showMovieInformation ?
-              <div className={styles.movieInfo}>
-                <div className={styles.genres}>
-                  {joinedGenres}
-                </div>
-              </div> :
-              null
-          }
-
-          {
-            showMovieInformation ?
-              <div className={styles.movieInfo}>
-                <div className={styles.genres}>
-                  {eventType.join(', ')}
-                </div>
-                <div>
-                  {certification}
-                </div>
-              </div> :
-              null
-          }
-        </div>
-      </div>
-    );
-  }
-}
-
-CalendarEvent.propTypes = {
-  id: PropTypes.number.isRequired,
-  genres: PropTypes.arrayOf(PropTypes.string).isRequired,
-  movieFile: PropTypes.object,
-  title: PropTypes.string.isRequired,
-  titleSlug: PropTypes.string.isRequired,
-  isAvailable: PropTypes.bool.isRequired,
-  inCinemas: PropTypes.string,
-  physicalRelease: PropTypes.string,
-  digitalRelease: PropTypes.string,
-  date: PropTypes.string.isRequired,
-  monitored: PropTypes.bool.isRequired,
-  certification: PropTypes.string,
-  hasFile: PropTypes.bool.isRequired,
-  grabbed: PropTypes.bool,
-  queueItem: PropTypes.object,
-  // These props come from the connector, not marked as required to appease TS for now.
-  showMovieInformation: PropTypes.bool,
-  showCutoffUnmetIcon: PropTypes.bool,
-  fullColorEvents: PropTypes.bool,
-  timeFormat: PropTypes.string,
-  colorImpairedMode: PropTypes.bool
-};
-
-CalendarEvent.defaultProps = {
-  genres: []
-};
-
-export default CalendarEvent;

frontend/src/Calendar/Events/CalendarEvent.tsx

@@ -0,0 +1,180 @@
+import classNames from 'classnames';
+import moment from 'moment';
+import React, { useMemo } from 'react';
+import { useSelector } from 'react-redux';
+import AppState from 'App/State/AppState';
+import getStatusStyle from 'Calendar/getStatusStyle';
+import Icon from 'Components/Icon';
+import Link from 'Components/Link/Link';
+import { icons, kinds } from 'Helpers/Props';
+import useMovieFile from 'MovieFile/useMovieFile';
+import { createQueueItemSelectorForHook } from 'Store/Selectors/createQueueItemSelector';
+import createUISettingsSelector from 'Store/Selectors/createUISettingsSelector';
+import translate from 'Utilities/String/translate';
+import CalendarEventQueueDetails from './CalendarEventQueueDetails';
+import styles from './CalendarEvent.css';
+
+interface CalendarEventProps {
+  id: number;
+  movieFileId?: number;
+  title: string;
+  titleSlug: string;
+  genres: string[];
+  certification?: string;
+  date: string;
+  inCinemas?: string;
+  digitalRelease?: string;
+  physicalRelease?: string;
+  isAvailable: boolean;
+  monitored: boolean;
+  hasFile: boolean;
+  grabbed?: boolean;
+}
+
+function CalendarEvent({
+  id,
+  movieFileId,
+  title,
+  titleSlug,
+  genres = [],
+  certification,
+  date,
+  inCinemas,
+  digitalRelease,
+  physicalRelease,
+  isAvailable,
+  monitored: isMonitored,
+  hasFile,
+  grabbed,
+}: CalendarEventProps) {
+  const movieFile = useMovieFile(movieFileId);
+  const queueItem = useSelector(createQueueItemSelectorForHook(id));
+
+  const { enableColorImpairedMode } = useSelector(createUISettingsSelector());
+
+  const {
+    showMovieInformation,
+    showCinemaRelease,
+    showDigitalRelease,
+    showPhysicalRelease,
+    showCutoffUnmetIcon,
+    fullColorEvents,
+  } = useSelector((state: AppState) => state.calendar.options);
+
+  const isDownloading = !!(queueItem || grabbed);
+  const statusStyle = getStatusStyle(
+    hasFile,
+    isDownloading,
+    isMonitored,
+    isAvailable
+  );
+  const joinedGenres = genres.slice(0, 2).join(', ');
+  const link = `/movie/${titleSlug}`;
+
+  const eventTypes = useMemo(() => {
+    const momentDate = moment(date);
+
+    const types = [];
+
+    if (
+      showCinemaRelease &&
+      inCinemas &&
+      momentDate.isSame(moment(inCinemas), 'day')
+    ) {
+      types.push('Cinemas');
+    }
+
+    if (
+      showDigitalRelease &&
+      digitalRelease &&
+      momentDate.isSame(moment(digitalRelease), 'day')
+    ) {
+      types.push('Digital');
+    }
+
+    if (
+      showPhysicalRelease &&
+      physicalRelease &&
+      momentDate.isSame(moment(physicalRelease), 'day')
+    ) {
+      types.push('Physical');
+    }
+
+    return types;
+  }, [
+    date,
+    showCinemaRelease,
+    showDigitalRelease,
+    showPhysicalRelease,
+    inCinemas,
+    digitalRelease,
+    physicalRelease,
+  ]);
+
+  return (
+    <div
+      className={classNames(
+        styles.event,
+        styles[statusStyle],
+        enableColorImpairedMode && 'colorImpaired',
+        fullColorEvents && 'fullColor'
+      )}
+    >
+      <Link className={styles.underlay} to={link} />
+
+      <div className={styles.overlay}>
+        <div className={styles.info}>
+          <div className={styles.movieTitle}>{title}</div>
+
+          <div
+            className={classNames(
+              styles.statusContainer,
+              fullColorEvents && 'fullColor'
+            )}
+          >
+            {queueItem ? (
+              <span className={styles.statusIcon}>
+                <CalendarEventQueueDetails {...queueItem} />
+              </span>
+            ) : null}
+
+            {!queueItem && grabbed ? (
+              <Icon
+                className={styles.statusIcon}
+                name={icons.DOWNLOADING}
+                title={translate('MovieIsDownloading')}
+              />
+            ) : null}
+
+            {showCutoffUnmetIcon &&
+            !!movieFile &&
+            movieFile.qualityCutoffNotMet ? (
+              <Icon
+                className={styles.statusIcon}
+                name={icons.MOVIE_FILE}
+                kind={kinds.WARNING}
+                title={translate('QualityCutoffNotMet')}
+              />
+            ) : null}
+          </div>
+        </div>
+
+        {showMovieInformation ? (
+          <>
+            <div className={styles.movieInfo}>
+              <div className={styles.genres}>{joinedGenres}</div>
+            </div>
+
+            <div className={styles.movieInfo}>
+              <div className={styles.eventType}>{eventTypes.join(', ')}</div>
+
+              <div>{certification}</div>
+            </div>
+          </>
+        ) : null}
+      </div>
+    </div>
+  );
+}
+
+export default CalendarEvent;

frontend/src/Calendar/Events/CalendarEventConnector.js

@@ -1,26 +0,0 @@
-import { connect } from 'react-redux';
-import { createSelector } from 'reselect';
-import createMovieSelector from 'Store/Selectors/createMovieSelector';
-import createQueueItemSelector from 'Store/Selectors/createQueueItemSelector';
-import createUISettingsSelector from 'Store/Selectors/createUISettingsSelector';
-import CalendarEvent from './CalendarEvent';
-
-function createMapStateToProps() {
-  return createSelector(
-    (state) => state.calendar.options,
-    createMovieSelector(),
-    createQueueItemSelector(),
-    createUISettingsSelector(),
-    (calendarOptions, movie, queueItem, uiSettings) => {
-      return {
-        movie,
-        queueItem,
-        ...calendarOptions,
-        timeFormat: uiSettings.timeFormat,
-        colorImpairedMode: uiSettings.enableColorImpairedMode
-      };
-    }
-  );
-}
-
-export default connect(createMapStateToProps)(CalendarEvent);

frontend/src/Calendar/Events/CalendarEventQueueDetails.js

@@ -1,56 +0,0 @@
-import PropTypes from 'prop-types';
-import React from 'react';
-import QueueDetails from 'Activity/Queue/QueueDetails';
-import CircularProgressBar from 'Components/CircularProgressBar';
-
-function CalendarEventQueueDetails(props) {
-  const {
-    title,
-    size,
-    sizeleft,
-    estimatedCompletionTime,
-    status,
-    trackedDownloadState,
-    trackedDownloadStatus,
-    statusMessages,
-    errorMessage
-  } = props;
-
-  const progress = size ? (100 - sizeleft / size * 100) : 0;
-
-  return (
-    <QueueDetails
-      title={title}
-      size={size}
-      sizeleft={sizeleft}
-      estimatedCompletionTime={estimatedCompletionTime}
-      status={status}
-      trackedDownloadState={trackedDownloadState}
-      trackedDownloadStatus={trackedDownloadStatus}
-      statusMessages={statusMessages}
-      errorMessage={errorMessage}
-      progressBar={
-        <CircularProgressBar
-          progress={progress}
-          size={20}
-          strokeWidth={2}
-          strokeColor={'#7a43b6'}
-        />
-      }
-    />
-  );
-}
-
-CalendarEventQueueDetails.propTypes = {
-  title: PropTypes.string.isRequired,
-  size: PropTypes.number.isRequired,
-  sizeleft: PropTypes.number.isRequired,
-  estimatedCompletionTime: PropTypes.string,
-  status: PropTypes.string.isRequired,
-  trackedDownloadState: PropTypes.string.isRequired,
-  trackedDownloadStatus: PropTypes.string.isRequired,
-  statusMessages: PropTypes.arrayOf(PropTypes.object),
-  errorMessage: PropTypes.string
-};
-
-export default CalendarEventQueueDetails;

frontend/src/Calendar/Events/CalendarEventQueueDetails.tsx

@@ -0,0 +1,58 @@
+import React from 'react';
+import QueueDetails from 'Activity/Queue/QueueDetails';
+import CircularProgressBar from 'Components/CircularProgressBar';
+import {
+  QueueTrackedDownloadState,
+  QueueTrackedDownloadStatus,
+  StatusMessage,
+} from 'typings/Queue';
+
+interface CalendarEventQueueDetailsProps {
+  title: string;
+  size: number;
+  sizeleft: number;
+  estimatedCompletionTime?: string;
+  status: string;
+  trackedDownloadState: QueueTrackedDownloadState;
+  trackedDownloadStatus: QueueTrackedDownloadStatus;
+  statusMessages?: StatusMessage[];
+  errorMessage?: string;
+}
+
+function CalendarEventQueueDetails({
+  title,
+  size,
+  sizeleft,
+  estimatedCompletionTime,
+  status,
+  trackedDownloadState,
+  trackedDownloadStatus,
+  statusMessages,
+  errorMessage,
+}: CalendarEventQueueDetailsProps) {
+  const progress = size ? 100 - (sizeleft / size) * 100 : 0;
+
+  return (
+    <QueueDetails
+      title={title}
+      size={size}
+      sizeleft={sizeleft}
+      estimatedCompletionTime={estimatedCompletionTime}
+      status={status}
+      trackedDownloadState={trackedDownloadState}
+      trackedDownloadStatus={trackedDownloadStatus}
+      statusMessages={statusMessages}
+      errorMessage={errorMessage}
+      progressBar={
+        <CircularProgressBar
+          progress={progress}
+          size={20}
+          strokeWidth={2}
+          strokeColor="#7a43b6"
+        />
+      }
+    />
+  );
+}
+
+export default CalendarEventQueueDetails;

frontend/src/Calendar/Header/CalendarHeader.js

@@ -1,268 +0,0 @@
-import moment from 'moment';
-import PropTypes from 'prop-types';
-import React, { Component } from 'react';
-import * as calendarViews from 'Calendar/calendarViews';
-import Icon from 'Components/Icon';
-import Button from 'Components/Link/Button';
-import LoadingIndicator from 'Components/Loading/LoadingIndicator';
-import Menu from 'Components/Menu/Menu';
-import MenuButton from 'Components/Menu/MenuButton';
-import MenuContent from 'Components/Menu/MenuContent';
-import ViewMenuItem from 'Components/Menu/ViewMenuItem';
-import { align, icons } from 'Helpers/Props';
-import translate from 'Utilities/String/translate';
-import CalendarHeaderViewButton from './CalendarHeaderViewButton';
-import styles from './CalendarHeader.css';
-
-function getTitle(time, start, end, view, longDateFormat) {
-  const timeMoment = moment(time);
-  const startMoment = moment(start);
-  const endMoment = moment(end);
-
-  if (view === 'day') {
-    return timeMoment.format(longDateFormat);
-  } else if (view === 'month') {
-    return timeMoment.format('MMMM YYYY');
-  } else if (view === 'agenda') {
-    return `Agenda: ${startMoment.format('MMM D')} - ${endMoment.format('MMM D')}`;
-  }
-
-  let startFormat = 'MMM D YYYY';
-  let endFormat = 'MMM D YYYY';
-
-  if (startMoment.isSame(endMoment, 'month')) {
-    startFormat = 'MMM D';
-    endFormat = 'D YYYY';
-  } else if (startMoment.isSame(endMoment, 'year')) {
-    startFormat = 'MMM D';
-    endFormat = 'MMM D YYYY';
-  }
-
-  return `${startMoment.format(startFormat)} \u2014 ${endMoment.format(endFormat)}`;
-}
-
-// TODO Convert to a stateful Component so we can track view internally when changed
-
-class CalendarHeader extends Component {
-
-  //
-  // Lifecycle
-
-  constructor(props, context) {
-    super(props, context);
-
-    this.state = {
-      view: props.view
-    };
-  }
-
-  componentDidUpdate(prevProps) {
-    const view = this.props.view;
-
-    if (prevProps.view !== view) {
-      this.setState({ view });
-    }
-  }
-
-  //
-  // Listeners
-
-  onViewChange = (view) => {
-    this.setState({ view }, () => {
-      this.props.onViewChange(view);
-    });
-  };
-
-  //
-  // Render
-
-  render() {
-    const {
-      isFetching,
-      time,
-      start,
-      end,
-      longDateFormat,
-      isSmallScreen,
-      collapseViewButtons,
-      onTodayPress,
-      onPreviousPress,
-      onNextPress
-    } = this.props;
-
-    const view = this.state.view;
-
-    const title = getTitle(time, start, end, view, longDateFormat);
-
-    return (
-      <div>
-        {
-          isSmallScreen &&
-            <div className={styles.titleMobile}>
-              {title}
-            </div>
-        }
-
-        <div className={styles.header}>
-          <div className={styles.navigationButtons}>
-            <Button
-              buttonGroupPosition={align.LEFT}
-              isDisabled={view === calendarViews.AGENDA}
-              onPress={onPreviousPress}
-            >
-              <Icon name={icons.PAGE_PREVIOUS} />
-            </Button>
-
-            <Button
-              buttonGroupPosition={align.RIGHT}
-              isDisabled={view === calendarViews.AGENDA}
-              onPress={onNextPress}
-            >
-              <Icon name={icons.PAGE_NEXT} />
-            </Button>
-
-            <Button
-              className={styles.todayButton}
-              isDisabled={view === calendarViews.AGENDA}
-              onPress={onTodayPress}
-            >
-              {translate('Today')}
-            </Button>
-          </div>
-
-          {
-            !isSmallScreen &&
-              <div className={styles.titleDesktop}>
-                {title}
-              </div>
-          }
-
-          <div className={styles.viewButtonsContainer}>
-            {
-              isFetching &&
-                <LoadingIndicator
-                  className={styles.loading}
-                  size={20}
-                />
-            }
-
-            {
-              collapseViewButtons ?
-                <Menu
-                  className={styles.viewMenu}
-                  alignMenu={align.RIGHT}
-                >
-                  <MenuButton>
-                    <Icon
-                      name={icons.VIEW}
-                      size={22}
-                    />
-                  </MenuButton>
-
-                  <MenuContent>
-                    {
-                      isSmallScreen ?
-                        null :
-                        <ViewMenuItem
-                          name={calendarViews.MONTH}
-                          selectedView={view}
-                          onPress={this.onViewChange}
-                        >
-                          {translate('Month')}
-                        </ViewMenuItem>
-                    }
-
-                    <ViewMenuItem
-                      name={calendarViews.WEEK}
-                      selectedView={view}
-                      onPress={this.onViewChange}
-                    >
-                      {translate('Week')}
-                    </ViewMenuItem>
-
-                    <ViewMenuItem
-                      name={calendarViews.FORECAST}
-                      selectedView={view}
-                      onPress={this.onViewChange}
-                    >
-                      {translate('Forecast')}
-                    </ViewMenuItem>
-
-                    <ViewMenuItem
-                      name={calendarViews.DAY}
-                      selectedView={view}
-                      onPress={this.onViewChange}
-                    >
-                      {translate('Day')}
-                    </ViewMenuItem>
-
-                    <ViewMenuItem
-                      name={calendarViews.AGENDA}
-                      selectedView={view}
-                      onPress={this.onViewChange}
-                    >
-                      {translate('Agenda')}
-                    </ViewMenuItem>
-                  </MenuContent>
-                </Menu> :
-
-                <div className={styles.viewButtons}>
-                  <CalendarHeaderViewButton
-                    view={calendarViews.MONTH}
-                    selectedView={view}
-                    buttonGroupPosition={align.LEFT}
-                    onPress={this.onViewChange}
-                  />
-
-                  <CalendarHeaderViewButton
-                    view={calendarViews.WEEK}
-                    selectedView={view}
-                    buttonGroupPosition={align.CENTER}
-                    onPress={this.onViewChange}
-                  />
-
-                  <CalendarHeaderViewButton
-                    view={calendarViews.FORECAST}
-                    selectedView={view}
-                    buttonGroupPosition={align.CENTER}
-                    onPress={this.onViewChange}
-                  />
-
-                  <CalendarHeaderViewButton
-                    view={calendarViews.DAY}
-                    selectedView={view}
-                    buttonGroupPosition={align.CENTER}
-                    onPress={this.onViewChange}
-                  />
-
-                  <CalendarHeaderViewButton
-                    view={calendarViews.AGENDA}
-                    selectedView={view}
-                    buttonGroupPosition={align.RIGHT}
-                    onPress={this.onViewChange}
-                  />
-                </div>
-            }
-          </div>
-        </div>
-      </div>
-    );
-  }
-}
-
-CalendarHeader.propTypes = {
-  isFetching: PropTypes.bool.isRequired,
-  time: PropTypes.string.isRequired,
-  start: PropTypes.string.isRequired,
-  end: PropTypes.string.isRequired,
-  view: PropTypes.oneOf(calendarViews.all).isRequired,
-  isSmallScreen: PropTypes.bool.isRequired,
-  collapseViewButtons: PropTypes.bool.isRequired,
-  longDateFormat: PropTypes.string.isRequired,
-  onViewChange: PropTypes.func.isRequired,
-  onTodayPress: PropTypes.func.isRequired,
-  onPreviousPress: PropTypes.func.isRequired,
-  onNextPress: PropTypes.func.isRequired
-};
-
-export default CalendarHeader;

frontend/src/Calendar/Header/CalendarHeader.tsx

@@ -0,0 +1,218 @@
+import moment from 'moment';
+import React, { useCallback, useMemo } from 'react';
+import { useDispatch, useSelector } from 'react-redux';
+import AppState from 'App/State/AppState';
+import Icon from 'Components/Icon';
+import Button from 'Components/Link/Button';
+import LoadingIndicator from 'Components/Loading/LoadingIndicator';
+import Menu from 'Components/Menu/Menu';
+import MenuButton from 'Components/Menu/MenuButton';
+import MenuContent from 'Components/Menu/MenuContent';
+import ViewMenuItem from 'Components/Menu/ViewMenuItem';
+import { align, icons } from 'Helpers/Props';
+import {
+  gotoCalendarNextRange,
+  gotoCalendarPreviousRange,
+  gotoCalendarToday,
+  setCalendarView,
+} from 'Store/Actions/calendarActions';
+import createDimensionsSelector from 'Store/Selectors/createDimensionsSelector';
+import createUISettingsSelector from 'Store/Selectors/createUISettingsSelector';
+import translate from 'Utilities/String/translate';
+import CalendarHeaderViewButton from './CalendarHeaderViewButton';
+import styles from './CalendarHeader.css';
+
+function CalendarHeader() {
+  const dispatch = useDispatch();
+
+  const { isFetching, view, time, start, end } = useSelector(
+    (state: AppState) => state.calendar
+  );
+
+  const { isSmallScreen, isLargeScreen } = useSelector(
+    createDimensionsSelector()
+  );
+
+  const { longDateFormat } = useSelector(createUISettingsSelector());
+
+  const handleViewChange = useCallback(
+    (newView: string) => {
+      dispatch(setCalendarView({ view: newView }));
+    },
+    [dispatch]
+  );
+
+  const handleTodayPress = useCallback(() => {
+    dispatch(gotoCalendarToday());
+  }, [dispatch]);
+
+  const handlePreviousPress = useCallback(() => {
+    dispatch(gotoCalendarPreviousRange());
+  }, [dispatch]);
+
+  const handleNextPress = useCallback(() => {
+    dispatch(gotoCalendarNextRange());
+  }, [dispatch]);
+
+  const title = useMemo(() => {
+    const timeMoment = moment(time);
+    const startMoment = moment(start);
+    const endMoment = moment(end);
+
+    if (view === 'day') {
+      return timeMoment.format(longDateFormat);
+    } else if (view === 'month') {
+      return timeMoment.format('MMMM YYYY');
+    }
+
+    let startFormat = 'MMM D YYYY';
+    let endFormat = 'MMM D YYYY';
+
+    if (startMoment.isSame(endMoment, 'month')) {
+      startFormat = 'MMM D';
+      endFormat = 'D YYYY';
+    } else if (startMoment.isSame(endMoment, 'year')) {
+      startFormat = 'MMM D';
+      endFormat = 'MMM D YYYY';
+    }
+
+    return `${startMoment.format(startFormat)} \u2014 ${endMoment.format(
+      endFormat
+    )}`;
+  }, [time, start, end, view, longDateFormat]);
+
+  return (
+    <div>
+      {isSmallScreen ? <div className={styles.titleMobile}>{title}</div> : null}
+
+      <div className={styles.header}>
+        <div className={styles.navigationButtons}>
+          <Button
+            buttonGroupPosition="left"
+            isDisabled={view === 'agenda'}
+            onPress={handlePreviousPress}
+          >
+            <Icon name={icons.PAGE_PREVIOUS} />
+          </Button>
+
+          <Button
+            buttonGroupPosition="right"
+            isDisabled={view === 'agenda'}
+            onPress={handleNextPress}
+          >
+            <Icon name={icons.PAGE_NEXT} />
+          </Button>
+
+          <Button
+            className={styles.todayButton}
+            isDisabled={view === 'agenda'}
+            onPress={handleTodayPress}
+          >
+            {translate('Today')}
+          </Button>
+        </div>
+
+        {isSmallScreen ? null : (
+          <div className={styles.titleDesktop}>{title}</div>
+        )}
+
+        <div className={styles.viewButtonsContainer}>
+          {isFetching ? (
+            <LoadingIndicator className={styles.loading} size={20} />
+          ) : null}
+
+          {isLargeScreen ? (
+            <Menu className={styles.viewMenu} alignMenu={align.RIGHT}>
+              <MenuButton>
+                <Icon name={icons.VIEW} size={22} />
+              </MenuButton>
+
+              <MenuContent>
+                {isSmallScreen ? null : (
+                  <ViewMenuItem
+                    name="month"
+                    selectedView={view}
+                    onPress={handleViewChange}
+                  >
+                    {translate('Month')}
+                  </ViewMenuItem>
+                )}
+
+                <ViewMenuItem
+                  name="week"
+                  selectedView={view}
+                  onPress={handleViewChange}
+                >
+                  {translate('Week')}
+                </ViewMenuItem>
+
+                <ViewMenuItem
+                  name="forecast"
+                  selectedView={view}
+                  onPress={handleViewChange}
+                >
+                  {translate('Forecast')}
+                </ViewMenuItem>
+
+                <ViewMenuItem
+                  name="day"
+                  selectedView={view}
+                  onPress={handleViewChange}
+                >
+                  {translate('Day')}
+                </ViewMenuItem>
+
+                <ViewMenuItem
+                  name="agenda"
+                  selectedView={view}
+                  onPress={handleViewChange}
+                >
+                  {translate('Agenda')}
+                </ViewMenuItem>
+              </MenuContent>
+            </Menu>
+          ) : (
+            <>
+              <CalendarHeaderViewButton
+                view="month"
+                selectedView={view}
+                buttonGroupPosition="left"
+                onPress={handleViewChange}
+              />
+
+              <CalendarHeaderViewButton
+                view="week"
+                selectedView={view}
+                buttonGroupPosition="center"
+                onPress={handleViewChange}
+              />
+
+              <CalendarHeaderViewButton
+                view="forecast"
+                selectedView={view}
+                buttonGroupPosition="center"
+                onPress={handleViewChange}
+              />
+
+              <CalendarHeaderViewButton
+                view="day"
+                selectedView={view}
+                buttonGroupPosition="center"
+                onPress={handleViewChange}
+              />
+
+              <CalendarHeaderViewButton
+                view="agenda"
+                selectedView={view}
+                buttonGroupPosition="right"
+                onPress={handleViewChange}
+              />
+            </>
+          )}
+        </div>
+      </div>
+    </div>
+  );
+}
+
+export default CalendarHeader;

frontend/src/Calendar/Header/CalendarHeaderConnector.js

@@ -1,81 +0,0 @@
-import PropTypes from 'prop-types';
-import React, { Component } from 'react';
-import { connect } from 'react-redux';
-import { createSelector } from 'reselect';
-import { gotoCalendarNextRange, gotoCalendarPreviousRange, gotoCalendarToday, setCalendarView } from 'Store/Actions/calendarActions';
-import createDimensionsSelector from 'Store/Selectors/createDimensionsSelector';
-import createUISettingsSelector from 'Store/Selectors/createUISettingsSelector';
-import CalendarHeader from './CalendarHeader';
-
-function createMapStateToProps() {
-  return createSelector(
-    (state) => state.calendar,
-    createDimensionsSelector(),
-    createUISettingsSelector(),
-    (calendar, dimensions, uiSettings) => {
-      return {
-        isFetching: calendar.isFetching,
-        view: calendar.view,
-        time: calendar.time,
-        start: calendar.start,
-        end: calendar.end,
-        isSmallScreen: dimensions.isSmallScreen,
-        collapseViewButtons: dimensions.isLargeScreen,
-        longDateFormat: uiSettings.longDateFormat
-      };
-    }
-  );
-}
-
-const mapDispatchToProps = {
-  setCalendarView,
-  gotoCalendarToday,
-  gotoCalendarPreviousRange,
-  gotoCalendarNextRange
-};
-
-class CalendarHeaderConnector extends Component {
-
-  //
-  // Listeners
-
-  onViewChange = (view) => {
-    this.props.setCalendarView({ view });
-  };
-
-  onTodayPress = () => {
-    this.props.gotoCalendarToday();
-  };
-
-  onPreviousPress = () => {
-    this.props.gotoCalendarPreviousRange();
-  };
-
-  onNextPress = () => {
-    this.props.gotoCalendarNextRange();
-  };
-
-  //
-  // Render
-
-  render() {
-    return (
-      <CalendarHeader
-        {...this.props}
-        onViewChange={this.onViewChange}
-        onTodayPress={this.onTodayPress}
-        onPreviousPress={this.onPreviousPress}
-        onNextPress={this.onNextPress}
-      />
-    );
-  }
-}
-
-CalendarHeaderConnector.propTypes = {
-  setCalendarView: PropTypes.func.isRequired,
-  gotoCalendarToday: PropTypes.func.isRequired,
-  gotoCalendarPreviousRange: PropTypes.func.isRequired,
-  gotoCalendarNextRange: PropTypes.func.isRequired
-};
-
-export default connect(createMapStateToProps, mapDispatchToProps)(CalendarHeaderConnector);

frontend/src/Calendar/Header/CalendarHeaderViewButton.js

@@ -1,45 +0,0 @@
-import PropTypes from 'prop-types';
-import React, { Component } from 'react';
-import * as calendarViews from 'Calendar/calendarViews';
-import Button from 'Components/Link/Button';
-import titleCase from 'Utilities/String/titleCase';
-// import styles from './CalendarHeaderViewButton.css';
-
-class CalendarHeaderViewButton extends Component {
-
-  //
-  // Listeners
-
-  onPress = () => {
-    this.props.onPress(this.props.view);
-  };
-
-  //
-  // Render
-
-  render() {
-    const {
-      view,
-      selectedView,
-      ...otherProps
-    } = this.props;
-
-    return (
-      <Button
-        isDisabled={selectedView === view}
-        {...otherProps}
-        onPress={this.onPress}
-      >
-        {titleCase(view)}
-      </Button>
-    );
-  }
-}
-
-CalendarHeaderViewButton.propTypes = {
-  view: PropTypes.oneOf(calendarViews.all).isRequired,
-  selectedView: PropTypes.oneOf(calendarViews.all).isRequired,
-  onPress: PropTypes.func.isRequired
-};
-
-export default CalendarHeaderViewButton;

frontend/src/Calendar/Header/CalendarHeaderViewButton.tsx

@@ -0,0 +1,34 @@
+import React, { useCallback } from 'react';
+import { CalendarView } from 'Calendar/calendarViews';
+import Button, { ButtonProps } from 'Components/Link/Button';
+import titleCase from 'Utilities/String/titleCase';
+
+interface CalendarHeaderViewButtonProps
+  extends Omit<ButtonProps, 'children' | 'onPress'> {
+  view: CalendarView;
+  selectedView: CalendarView;
+  onPress: (view: CalendarView) => void;
+}
+
+function CalendarHeaderViewButton({
+  view,
+  selectedView,
+  onPress,
+  ...otherProps
+}: CalendarHeaderViewButtonProps) {
+  const handlePress = useCallback(() => {
+    onPress(view);
+  }, [view, onPress]);
+
+  return (
+    <Button
+      isDisabled={selectedView === view}
+      {...otherProps}
+      onPress={handlePress}
+    >
+      {titleCase(view)}
+    </Button>
+  );
+}
+
+export default CalendarHeaderViewButton;

frontend/src/Calendar/Legend/Legend.tsx

@@ -1,18 +1,19 @@
-import PropTypes from 'prop-types';
 import React from 'react';
+import { useSelector } from 'react-redux';
+import AppState from 'App/State/AppState';
 import { icons, kinds } from 'Helpers/Props';
+import createUISettingsSelector from 'Store/Selectors/createUISettingsSelector';
 import translate from 'Utilities/String/translate';
 import LegendIconItem from './LegendIconItem';
 import LegendItem from './LegendItem';
 import styles from './Legend.css';
 
-function Legend(props) {
-  const {
-    view,
-    showCutoffUnmetIcon,
-    fullColorEvents,
-    colorImpairedMode
-  } = props;
+function Legend() {
+  const view = useSelector((state: AppState) => state.calendar.view);
+  const { showCutoffUnmetIcon, fullColorEvents } = useSelector(
+    (state: AppState) => state.calendar.options
+  );
+  const { enableColorImpairedMode } = useSelector(createUISettingsSelector());
 
   const iconsToShow = [];
   const isAgendaView = view === 'agenda';
@@ -37,7 +38,7 @@ function Legend(props) {
           name={translate('DownloadedAndMonitored')}
           isAgendaView={isAgendaView}
           fullColorEvents={fullColorEvents}
-          colorImpairedMode={colorImpairedMode}
+          colorImpairedMode={enableColorImpairedMode}
         />
 
         <LegendItem
@@ -45,7 +46,7 @@ function Legend(props) {
           name={translate('DownloadedButNotMonitored')}
           isAgendaView={isAgendaView}
           fullColorEvents={fullColorEvents}
-          colorImpairedMode={colorImpairedMode}
+          colorImpairedMode={enableColorImpairedMode}
         />
       </div>
 
@@ -55,7 +56,7 @@ function Legend(props) {
           name={translate('MissingMonitoredAndConsideredAvailable')}
           isAgendaView={isAgendaView}
           fullColorEvents={fullColorEvents}
-          colorImpairedMode={colorImpairedMode}
+          colorImpairedMode={enableColorImpairedMode}
         />
 
         <LegendItem
@@ -63,7 +64,7 @@ function Legend(props) {
           name={translate('MissingNotMonitored')}
           isAgendaView={isAgendaView}
           fullColorEvents={fullColorEvents}
-          colorImpairedMode={colorImpairedMode}
+          colorImpairedMode={enableColorImpairedMode}
         />
       </div>
 
@@ -73,7 +74,7 @@ function Legend(props) {
           name={translate('Queued')}
           isAgendaView={isAgendaView}
           fullColorEvents={fullColorEvents}
-          colorImpairedMode={colorImpairedMode}
+          colorImpairedMode={enableColorImpairedMode}
         />
 
         <LegendItem
@@ -81,25 +82,13 @@ function Legend(props) {
           name={translate('Unreleased')}
           isAgendaView={isAgendaView}
           fullColorEvents={fullColorEvents}
-          colorImpairedMode={colorImpairedMode}
+          colorImpairedMode={enableColorImpairedMode}
         />
       </div>
 
-      {
-        iconsToShow.length > 0 &&
-          <div>
-            {iconsToShow[0]}
-          </div>
-      }
+      {iconsToShow.length > 0 ? <div>{iconsToShow[0]}</div> : null}
     </div>
   );
 }
 
-Legend.propTypes = {
-  view: PropTypes.string.isRequired,
-  showCutoffUnmetIcon: PropTypes.bool.isRequired,
-  fullColorEvents: PropTypes.bool.isRequired,
-  colorImpairedMode: PropTypes.bool.isRequired
-};
-
 export default Legend;

frontend/src/Calendar/Legend/LegendConnector.js

@@ -1,21 +0,0 @@
-import { connect } from 'react-redux';
-import { createSelector } from 'reselect';
-import createUISettingsSelector from 'Store/Selectors/createUISettingsSelector';
-import Legend from './Legend';
-
-function createMapStateToProps() {
-  return createSelector(
-    (state) => state.calendar.options,
-    (state) => state.calendar.view,
-    createUISettingsSelector(),
-    (calendarOptions, view, uiSettings) => {
-      return {
-        ...calendarOptions,
-        view,
-        colorImpairedMode: uiSettings.enableColorImpairedMode
-      };
-    }
-  );
-}
-
-export default connect(createMapStateToProps)(Legend);

frontend/src/Calendar/Legend/LegendIconItem.js

@@ -1,43 +0,0 @@
-import classNames from 'classnames';
-import PropTypes from 'prop-types';
-import React from 'react';
-import Icon from 'Components/Icon';
-import styles from './LegendIconItem.css';
-
-function LegendIconItem(props) {
-  const {
-    name,
-    fullColorEvents,
-    icon,
-    kind,
-    tooltip
-  } = props;
-
-  return (
-    <div
-      className={styles.legendIconItem}
-      title={tooltip}
-    >
-      <Icon
-        className={classNames(
-          styles.icon,
-          fullColorEvents && 'fullColorEvents'
-        )}
-        name={icon}
-        kind={kind}
-      />
-
-      {name}
-    </div>
-  );
-}
-
-LegendIconItem.propTypes = {
-  name: PropTypes.string.isRequired,
-  fullColorEvents: PropTypes.bool.isRequired,
-  icon: PropTypes.object.isRequired,
-  kind: PropTypes.string.isRequired,
-  tooltip: PropTypes.string.isRequired
-};
-
-export default LegendIconItem;

frontend/src/Calendar/Legend/LegendIconItem.tsx

@@ -0,0 +1,33 @@
+import { FontAwesomeIconProps } from '@fortawesome/react-fontawesome';
+import classNames from 'classnames';
+import React from 'react';
+import Icon, { IconProps } from 'Components/Icon';
+import styles from './LegendIconItem.css';
+
+interface LegendIconItemProps extends Pick<IconProps, 'kind'> {
+  name: string;
+  fullColorEvents: boolean;
+  icon: FontAwesomeIconProps['icon'];
+  tooltip: string;
+}
+
+function LegendIconItem(props: LegendIconItemProps) {
+  const { name, fullColorEvents, icon, kind, tooltip } = props;
+
+  return (
+    <div className={styles.legendIconItem} title={tooltip}>
+      <Icon
+        className={classNames(
+          styles.icon,
+          fullColorEvents && 'fullColorEvents'
+        )}
+        name={icon}
+        kind={kind}
+      />
+
+      {name}
+    </div>
+  );
+}
+
+export default LegendIconItem;

frontend/src/Calendar/Legend/LegendItem.js

@@ -1,37 +0,0 @@
-import classNames from 'classnames';
-import PropTypes from 'prop-types';
-import React from 'react';
-import styles from './LegendItem.css';
-
-function LegendItem(props) {
-  const {
-    name,
-    status,
-    isAgendaView,
-    fullColorEvents,
-    colorImpairedMode
-  } = props;
-
-  return (
-    <div
-      className={classNames(
-        styles.legendItem,
-        styles[status],
-        colorImpairedMode && 'colorImpaired',
-        fullColorEvents && !isAgendaView && 'fullColor'
-      )}
-    >
-      {name}
-    </div>
-  );
-}
-
-LegendItem.propTypes = {
-  name: PropTypes.string.isRequired,
-  status: PropTypes.string.isRequired,
-  isAgendaView: PropTypes.bool.isRequired,
-  fullColorEvents: PropTypes.bool.isRequired,
-  colorImpairedMode: PropTypes.bool.isRequired
-};
-
-export default LegendItem;

frontend/src/Calendar/Legend/LegendItem.tsx

@@ -0,0 +1,35 @@
+import classNames from 'classnames';
+import React from 'react';
+import { CalendarStatus } from 'typings/Calendar';
+import styles from './LegendItem.css';
+
+interface LegendItemProps {
+  name: string;
+  status: CalendarStatus;
+  isAgendaView: boolean;
+  fullColorEvents: boolean;
+  colorImpairedMode: boolean;
+}
+
+function LegendItem({
+  name,
+  status,
+  isAgendaView,
+  fullColorEvents,
+  colorImpairedMode,
+}: LegendItemProps) {
+  return (
+    <div
+      className={classNames(
+        styles.legendItem,
+        styles[status],
+        colorImpairedMode && 'colorImpaired',
+        fullColorEvents && !isAgendaView && 'fullColor'
+      )}
+    >
+      {name}
+    </div>
+  );
+}
+
+export default LegendItem;

frontend/src/Calendar/Options/CalendarOptionsModal.js

@@ -1,29 +0,0 @@
-import PropTypes from 'prop-types';
-import React from 'react';
-import Modal from 'Components/Modal/Modal';
-import CalendarOptionsModalContentConnector from './CalendarOptionsModalContentConnector';
-
-function CalendarOptionsModal(props) {
-  const {
-    isOpen,
-    onModalClose
-  } = props;
-
-  return (
-    <Modal
-      isOpen={isOpen}
-      onModalClose={onModalClose}
-    >
-      <CalendarOptionsModalContentConnector
-        onModalClose={onModalClose}
-      />
-    </Modal>
-  );
-}
-
-CalendarOptionsModal.propTypes = {
-  isOpen: PropTypes.bool.isRequired,
-  onModalClose: PropTypes.func.isRequired
-};
-
-export default CalendarOptionsModal;

frontend/src/Calendar/Options/CalendarOptionsModal.tsx

@@ -0,0 +1,21 @@
+import React from 'react';
+import Modal from 'Components/Modal/Modal';
+import CalendarOptionsModalContent from './CalendarOptionsModalContent';
+
+interface CalendarOptionsModalProps {
+  isOpen: boolean;
+  onModalClose: () => void;
+}
+
+function CalendarOptionsModal({
+  isOpen,
+  onModalClose,
+}: CalendarOptionsModalProps) {
+  return (
+    <Modal isOpen={isOpen} onModalClose={onModalClose}>
+      <CalendarOptionsModalContent onModalClose={onModalClose} />
+    </Modal>
+  );
+}
+
+export default CalendarOptionsModal;

frontend/src/Calendar/Options/CalendarOptionsModalContent.js

@@ -1,234 +0,0 @@
-import PropTypes from 'prop-types';
-import React, { Component } from 'react';
-import FieldSet from 'Components/FieldSet';
-import Form from 'Components/Form/Form';
-import FormGroup from 'Components/Form/FormGroup';
-import FormInputGroup from 'Components/Form/FormInputGroup';
-import FormLabel from 'Components/Form/FormLabel';
-import Button from 'Components/Link/Button';
-import ModalBody from 'Components/Modal/ModalBody';
-import ModalContent from 'Components/Modal/ModalContent';
-import ModalFooter from 'Components/Modal/ModalFooter';
-import ModalHeader from 'Components/Modal/ModalHeader';
-import { inputTypes } from 'Helpers/Props';
-import { firstDayOfWeekOptions, timeFormatOptions, weekColumnOptions } from 'Settings/UI/UISettings';
-import translate from 'Utilities/String/translate';
-
-class CalendarOptionsModalContent extends Component {
-
-  //
-  // Lifecycle
-
-  constructor(props, context) {
-    super(props, context);
-
-    const {
-      firstDayOfWeek,
-      calendarWeekColumnHeader,
-      timeFormat,
-      enableColorImpairedMode,
-      fullColorEvents
-    } = props;
-
-    this.state = {
-      firstDayOfWeek,
-      calendarWeekColumnHeader,
-      timeFormat,
-      enableColorImpairedMode,
-      fullColorEvents
-    };
-  }
-
-  componentDidUpdate(prevProps) {
-    const {
-      firstDayOfWeek,
-      calendarWeekColumnHeader,
-      timeFormat,
-      enableColorImpairedMode
-    } = this.props;
-
-    if (
-      prevProps.firstDayOfWeek !== firstDayOfWeek ||
-      prevProps.calendarWeekColumnHeader !== calendarWeekColumnHeader ||
-      prevProps.timeFormat !== timeFormat ||
-      prevProps.enableColorImpairedMode !== enableColorImpairedMode
-    ) {
-      this.setState({
-        firstDayOfWeek,
-        calendarWeekColumnHeader,
-        timeFormat,
-        enableColorImpairedMode
-      });
-    }
-  }
-
-  //
-  // Listeners
-
-  onOptionInputChange = ({ name, value }) => {
-    const {
-      dispatchSetCalendarOption
-    } = this.props;
-
-    dispatchSetCalendarOption({ [name]: value });
-  };
-
-  onGlobalInputChange = ({ name, value }) => {
-    const {
-      dispatchSaveUISettings
-    } = this.props;
-
-    const setting = { [name]: value };
-
-    this.setState(setting, () => {
-      dispatchSaveUISettings(setting);
-    });
-  };
-
-  onLinkFocus = (event) => {
-    event.target.select();
-  };
-
-  //
-  // Render
-
-  render() {
-    const {
-      showMovieInformation,
-      showCutoffUnmetIcon,
-      fullColorEvents,
-      onModalClose
-    } = this.props;
-
-    const {
-      firstDayOfWeek,
-      calendarWeekColumnHeader,
-      timeFormat,
-      enableColorImpairedMode
-    } = this.state;
-
-    return (
-      <ModalContent onModalClose={onModalClose}>
-        <ModalHeader>
-          {translate('CalendarOptions')}
-        </ModalHeader>
-
-        <ModalBody>
-          <FieldSet legend={translate('Local')}>
-            <Form>
-              <FormGroup>
-                <FormLabel>{translate('ShowMovieInformation')}</FormLabel>
-
-                <FormInputGroup
-                  type={inputTypes.CHECK}
-                  name="showMovieInformation"
-                  value={showMovieInformation}
-                  helpText={translate('ShowMovieInformationHelpText')}
-                  onChange={this.onOptionInputChange}
-                />
-              </FormGroup>
-
-              <FormGroup>
-                <FormLabel>{translate('IconForCutoffUnmet')}</FormLabel>
-
-                <FormInputGroup
-                  type={inputTypes.CHECK}
-                  name="showCutoffUnmetIcon"
-                  value={showCutoffUnmetIcon}
-                  helpText={translate('IconForCutoffUnmetHelpText')}
-                  onChange={this.onOptionInputChange}
-                />
-              </FormGroup>
-
-              <FormGroup>
-                <FormLabel>{translate('FullColorEvents')}</FormLabel>
-
-                <FormInputGroup
-                  type={inputTypes.CHECK}
-                  name="fullColorEvents"
-                  value={fullColorEvents}
-                  helpText={translate('FullColorEventsHelpText')}
-                  onChange={this.onOptionInputChange}
-                />
-              </FormGroup>
-            </Form>
-          </FieldSet>
-
-          <FieldSet legend={translate('Global')}>
-            <Form>
-              <FormGroup>
-                <FormLabel>{translate('FirstDayOfWeek')}</FormLabel>
-
-                <FormInputGroup
-                  type={inputTypes.SELECT}
-                  name="firstDayOfWeek"
-                  values={firstDayOfWeekOptions}
-                  value={firstDayOfWeek}
-                  onChange={this.onGlobalInputChange}
-                />
-              </FormGroup>
-
-              <FormGroup>
-                <FormLabel>{translate('WeekColumnHeader')}</FormLabel>
-
-                <FormInputGroup
-                  type={inputTypes.SELECT}
-                  name="calendarWeekColumnHeader"
-                  values={weekColumnOptions}
-                  value={calendarWeekColumnHeader}
-                  onChange={this.onGlobalInputChange}
-                  helpText={translate('WeekColumnHeaderHelpText')}
-                />
-              </FormGroup>
-
-              <FormGroup>
-                <FormLabel>{translate('TimeFormat')}</FormLabel>
-
-                <FormInputGroup
-                  type={inputTypes.SELECT}
-                  name="timeFormat"
-                  values={timeFormatOptions}
-                  value={timeFormat}
-                  onChange={this.onGlobalInputChange}
-                />
-              </FormGroup>
-
-              <FormGroup>
-                <FormLabel>{translate('EnableColorImpairedMode')}</FormLabel>
-
-                <FormInputGroup
-                  type={inputTypes.CHECK}
-                  name="enableColorImpairedMode"
-                  value={enableColorImpairedMode}
-                  helpText={translate('EnableColorImpairedModeHelpText')}
-                  onChange={this.onGlobalInputChange}
-                />
-              </FormGroup>
-            </Form>
-          </FieldSet>
-        </ModalBody>
-
-        <ModalFooter>
-          <Button onPress={onModalClose}>
-            {translate('Close')}
-          </Button>
-        </ModalFooter>
-      </ModalContent>
-    );
-  }
-}
-
-CalendarOptionsModalContent.propTypes = {
-  showMovieInformation: PropTypes.bool.isRequired,
-  showCutoffUnmetIcon: PropTypes.bool.isRequired,
-  firstDayOfWeek: PropTypes.number.isRequired,
-  calendarWeekColumnHeader: PropTypes.string.isRequired,
-  timeFormat: PropTypes.string.isRequired,
-  enableColorImpairedMode: PropTypes.bool.isRequired,
-  fullColorEvents: PropTypes.bool.isRequired,
-  dispatchSetCalendarOption: PropTypes.func.isRequired,
-  dispatchSaveUISettings: PropTypes.func.isRequired,
-  onModalClose: PropTypes.func.isRequired
-};
-
-export default CalendarOptionsModalContent;

frontend/src/Calendar/Options/CalendarOptionsModalContent.tsx

@@ -0,0 +1,243 @@
+import React, { useCallback, useEffect, useState } from 'react';
+import { useDispatch, useSelector } from 'react-redux';
+import AppState from 'App/State/AppState';
+import FieldSet from 'Components/FieldSet';
+import Form from 'Components/Form/Form';
+import FormGroup from 'Components/Form/FormGroup';
+import FormInputGroup from 'Components/Form/FormInputGroup';
+import FormLabel from 'Components/Form/FormLabel';
+import Button from 'Components/Link/Button';
+import ModalBody from 'Components/Modal/ModalBody';
+import ModalContent from 'Components/Modal/ModalContent';
+import ModalFooter from 'Components/Modal/ModalFooter';
+import ModalHeader from 'Components/Modal/ModalHeader';
+import { inputTypes } from 'Helpers/Props';
+import {
+  firstDayOfWeekOptions,
+  timeFormatOptions,
+  weekColumnOptions,
+} from 'Settings/UI/UISettings';
+import { setCalendarOption } from 'Store/Actions/calendarActions';
+import { saveUISettings } from 'Store/Actions/settingsActions';
+import createUISettingsSelector from 'Store/Selectors/createUISettingsSelector';
+import { InputChanged } from 'typings/inputs';
+import UiSettings from 'typings/Settings/UiSettings';
+import translate from 'Utilities/String/translate';
+
+interface CalendarOptionsModalContentProps {
+  onModalClose: () => void;
+}
+
+function CalendarOptionsModalContent({
+  onModalClose,
+}: CalendarOptionsModalContentProps) {
+  const dispatch = useDispatch();
+
+  const {
+    showMovieInformation,
+    showCinemaRelease,
+    showDigitalRelease,
+    showPhysicalRelease,
+    showCutoffUnmetIcon,
+    fullColorEvents,
+  } = useSelector((state: AppState) => state.calendar.options);
+
+  const uiSettings = useSelector(createUISettingsSelector());
+
+  const [state, setState] = useState<Partial<UiSettings>>({
+    firstDayOfWeek: uiSettings.firstDayOfWeek,
+    calendarWeekColumnHeader: uiSettings.calendarWeekColumnHeader,
+    timeFormat: uiSettings.timeFormat,
+    enableColorImpairedMode: uiSettings.enableColorImpairedMode,
+  });
+
+  const {
+    firstDayOfWeek,
+    calendarWeekColumnHeader,
+    timeFormat,
+    enableColorImpairedMode,
+  } = state;
+
+  const handleOptionInputChange = useCallback(
+    ({ name, value }: InputChanged) => {
+      dispatch(setCalendarOption({ [name]: value }));
+    },
+    [dispatch]
+  );
+
+  const handleGlobalInputChange = useCallback(
+    ({ name, value }: InputChanged) => {
+      setState((prevState) => ({ ...prevState, [name]: value }));
+
+      dispatch(saveUISettings({ [name]: value }));
+    },
+    [dispatch]
+  );
+
+  useEffect(() => {
+    setState({
+      firstDayOfWeek: uiSettings.firstDayOfWeek,
+      calendarWeekColumnHeader: uiSettings.calendarWeekColumnHeader,
+      timeFormat: uiSettings.timeFormat,
+      enableColorImpairedMode: uiSettings.enableColorImpairedMode,
+    });
+  }, [uiSettings]);
+
+  return (
+    <ModalContent onModalClose={onModalClose}>
+      <ModalHeader>{translate('CalendarOptions')}</ModalHeader>
+
+      <ModalBody>
+        <FieldSet legend={translate('Local')}>
+          <Form>
+            <FormGroup>
+              <FormLabel>{translate('ShowMovieInformation')}</FormLabel>
+
+              <FormInputGroup
+                type={inputTypes.CHECK}
+                name="showMovieInformation"
+                value={showMovieInformation}
+                helpText={translate('ShowMovieInformationHelpText')}
+                onChange={handleOptionInputChange}
+              />
+            </FormGroup>
+
+            <FormGroup>
+              <FormLabel>{translate('ShowCinemaRelease')}</FormLabel>
+
+              <FormInputGroup
+                type={inputTypes.CHECK}
+                name="showCinemaRelease"
+                value={showCinemaRelease}
+                helpText={translate('ShowCinemaReleaseCalendarHelpText')}
+                isDisabled={
+                  showCinemaRelease &&
+                  !showDigitalRelease &&
+                  !showPhysicalRelease
+                }
+                onChange={handleOptionInputChange}
+              />
+            </FormGroup>
+
+            <FormGroup>
+              <FormLabel>{translate('ShowDigitalRelease')}</FormLabel>
+
+              <FormInputGroup
+                type={inputTypes.CHECK}
+                name="showDigitalRelease"
+                value={showDigitalRelease}
+                helpText={translate('ShowDigitalReleaseCalendarHelpText')}
+                isDisabled={
+                  !showCinemaRelease &&
+                  showDigitalRelease &&
+                  !showPhysicalRelease
+                }
+                onChange={handleOptionInputChange}
+              />
+            </FormGroup>
+
+            <FormGroup>
+              <FormLabel>{translate('ShowPhysicalRelease')}</FormLabel>
+
+              <FormInputGroup
+                type={inputTypes.CHECK}
+                name="showPhysicalRelease"
+                value={showPhysicalRelease}
+                helpText={translate('ShowPhysicalReleaseCalendarHelpText')}
+                isDisabled={
+                  !showCinemaRelease &&
+                  !showDigitalRelease &&
+                  showPhysicalRelease
+                }
+                onChange={handleOptionInputChange}
+              />
+            </FormGroup>
+
+            <FormGroup>
+              <FormLabel>{translate('IconForCutoffUnmet')}</FormLabel>
+
+              <FormInputGroup
+                type={inputTypes.CHECK}
+                name="showCutoffUnmetIcon"
+                value={showCutoffUnmetIcon}
+                helpText={translate('IconForCutoffUnmetHelpText')}
+                onChange={handleOptionInputChange}
+              />
+            </FormGroup>
+
+            <FormGroup>
+              <FormLabel>{translate('FullColorEvents')}</FormLabel>
+
+              <FormInputGroup
+                type={inputTypes.CHECK}
+                name="fullColorEvents"
+                value={fullColorEvents}
+                helpText={translate('FullColorEventsHelpText')}
+                onChange={handleOptionInputChange}
+              />
+            </FormGroup>
+          </Form>
+        </FieldSet>
+
+        <FieldSet legend={translate('Global')}>
+          <Form>
+            <FormGroup>
+              <FormLabel>{translate('FirstDayOfWeek')}</FormLabel>
+
+              <FormInputGroup
+                type={inputTypes.SELECT}
+                name="firstDayOfWeek"
+                values={firstDayOfWeekOptions}
+                value={firstDayOfWeek}
+                onChange={handleGlobalInputChange}
+              />
+            </FormGroup>
+
+            <FormGroup>
+              <FormLabel>{translate('WeekColumnHeader')}</FormLabel>
+
+              <FormInputGroup
+                type={inputTypes.SELECT}
+                name="calendarWeekColumnHeader"
+                values={weekColumnOptions}
+                value={calendarWeekColumnHeader}
+                helpText={translate('WeekColumnHeaderHelpText')}
+                onChange={handleGlobalInputChange}
+              />
+            </FormGroup>
+
+            <FormGroup>
+              <FormLabel>{translate('TimeFormat')}</FormLabel>
+
+              <FormInputGroup
+                type={inputTypes.SELECT}
+                name="timeFormat"
+                values={timeFormatOptions}
+                value={timeFormat}
+                onChange={handleGlobalInputChange}
+              />
+            </FormGroup>
+
+            <FormGroup>
+              <FormLabel>{translate('EnableColorImpairedMode')}</FormLabel>
+
+              <FormInputGroup
+                type={inputTypes.CHECK}
+                name="enableColorImpairedMode"
+                value={enableColorImpairedMode}
+                helpText={translate('EnableColorImpairedModeHelpText')}
+                onChange={handleGlobalInputChange}
+              />
+            </FormGroup>
+          </Form>
+        </FieldSet>
+      </ModalBody>
+
+      <ModalFooter>
+        <Button onPress={onModalClose}>{translate('Close')}</Button>
+      </ModalFooter>
+    </ModalContent>
+  );
+}
+
+export default CalendarOptionsModalContent;

frontend/src/Calendar/Options/CalendarOptionsModalContentConnector.js

@@ -1,25 +0,0 @@
-import { connect } from 'react-redux';
-import { createSelector } from 'reselect';
-import { setCalendarOption } from 'Store/Actions/calendarActions';
-import { saveUISettings } from 'Store/Actions/settingsActions';
-import CalendarOptionsModalContent from './CalendarOptionsModalContent';
-
-function createMapStateToProps() {
-  return createSelector(
-    (state) => state.calendar.options,
-    (state) => state.settings.ui.item,
-    (options, uiSettings) => {
-      return {
-        ...options,
-        ...uiSettings
-      };
-    }
-  );
-}
-
-const mapDispatchToProps = {
-  dispatchSetCalendarOption: setCalendarOption,
-  dispatchSaveUISettings: saveUISettings
-};
-
-export default connect(createMapStateToProps, mapDispatchToProps)(CalendarOptionsModalContent);

frontend/src/Calendar/calendarViews.ts

@@ -5,3 +5,5 @@ export const FORECAST = 'forecast';
 export const AGENDA = 'agenda';
 
 export const all = [DAY, WEEK, MONTH, FORECAST, AGENDA];
+
+export type CalendarView = 'agenda' | 'day' | 'forecast' | 'month' | 'week';

frontend/src/Calendar/getStatusStyle.ts

@@ -1,4 +1,9 @@
-function getStatusStyle(hasFile, downloading, isMonitored, isAvailable) {
+function getStatusStyle(
+  hasFile: boolean,
+  downloading: boolean,
+  isMonitored: boolean,
+  isAvailable: boolean
+) {
   if (downloading) {
     return 'queue';
   }

frontend/src/Calendar/iCal/CalendarLinkModal.js

@@ -1,29 +0,0 @@
-import PropTypes from 'prop-types';
-import React from 'react';
-import Modal from 'Components/Modal/Modal';
-import CalendarLinkModalContentConnector from './CalendarLinkModalContentConnector';
-
-function CalendarLinkModal(props) {
-  const {
-    isOpen,
-    onModalClose
-  } = props;
-
-  return (
-    <Modal
-      isOpen={isOpen}
-      onModalClose={onModalClose}
-    >
-      <CalendarLinkModalContentConnector
-        onModalClose={onModalClose}
-      />
-    </Modal>
-  );
-}
-
-CalendarLinkModal.propTypes = {
-  isOpen: PropTypes.bool.isRequired,
-  onModalClose: PropTypes.func.isRequired
-};
-
-export default CalendarLinkModal;

frontend/src/Calendar/iCal/CalendarLinkModal.tsx

@@ -0,0 +1,20 @@
+import React from 'react';
+import Modal from 'Components/Modal/Modal';
+import CalendarLinkModalContent from './CalendarLinkModalContent';
+
+interface CalendarLinkModalProps {
+  isOpen: boolean;
+  onModalClose: () => void;
+}
+
+function CalendarLinkModal(props: CalendarLinkModalProps) {
+  const { isOpen, onModalClose } = props;
+
+  return (
+    <Modal isOpen={isOpen} onModalClose={onModalClose}>
+      <CalendarLinkModalContent onModalClose={onModalClose} />
+    </Modal>
+  );
+}
+
+export default CalendarLinkModal;

frontend/src/Calendar/iCal/CalendarLinkModalContent.js

@@ -1,203 +0,0 @@
-import PropTypes from 'prop-types';
-import React, { Component } from 'react';
-import Form from 'Components/Form/Form';
-import FormGroup from 'Components/Form/FormGroup';
-import FormInputButton from 'Components/Form/FormInputButton';
-import FormInputGroup from 'Components/Form/FormInputGroup';
-import FormLabel from 'Components/Form/FormLabel';
-import Icon from 'Components/Icon';
-import Button from 'Components/Link/Button';
-import ClipboardButton from 'Components/Link/ClipboardButton';
-import ModalBody from 'Components/Modal/ModalBody';
-import ModalContent from 'Components/Modal/ModalContent';
-import ModalFooter from 'Components/Modal/ModalFooter';
-import ModalHeader from 'Components/Modal/ModalHeader';
-import { icons, inputTypes, kinds, sizes } from 'Helpers/Props';
-import translate from 'Utilities/String/translate';
-
-function getUrls(state) {
-  const {
-    unmonitored,
-    asAllDay,
-    tags
-  } = state;
-
-  let icalUrl = `${window.location.host}${window.Radarr.urlBase}/feed/v3/calendar/Radarr.ics?`;
-
-  if (unmonitored) {
-    icalUrl += 'unmonitored=true&';
-  }
-
-  if (asAllDay) {
-    icalUrl += 'asAllDay=true&';
-  }
-
-  if (tags.length) {
-    icalUrl += `tags=${tags.toString()}&`;
-  }
-
-  icalUrl += `apikey=${encodeURIComponent(window.Radarr.apiKey)}`;
-
-  const iCalHttpUrl = `${window.location.protocol}//${icalUrl}`;
-  const iCalWebCalUrl = `webcal://${icalUrl}`;
-
-  return {
-    iCalHttpUrl,
-    iCalWebCalUrl
-  };
-}
-
-class CalendarLinkModalContent extends Component {
-
-  //
-  // Lifecycle
-
-  constructor(props, context) {
-    super(props, context);
-
-    const defaultState = {
-      unmonitored: false,
-      asAllDay: false,
-      tags: []
-    };
-
-    const urls = getUrls(defaultState);
-
-    this.state = {
-      ...defaultState,
-      ...urls
-    };
-  }
-
-  //
-  // Listeners
-
-  onInputChange = ({ name, value }) => {
-    const state = {
-      ...this.state,
-      [name]: value
-    };
-
-    const urls = getUrls(state);
-
-    this.setState({
-      [name]: value,
-      ...urls
-    });
-  };
-
-  onLinkFocus = (event) => {
-    event.target.select();
-  };
-
-  //
-  // Render
-
-  render() {
-    const {
-      onModalClose
-    } = this.props;
-
-    const {
-      unmonitored,
-      asAllDay,
-      tags,
-      iCalHttpUrl,
-      iCalWebCalUrl
-    } = this.state;
-
-    return (
-      <ModalContent onModalClose={onModalClose}>
-        <ModalHeader>
-          {translate('CalendarFeed')}
-        </ModalHeader>
-
-        <ModalBody>
-          <Form>
-            <FormGroup>
-              <FormLabel>{translate('IncludeUnmonitored')}</FormLabel>
-
-              <FormInputGroup
-                type={inputTypes.CHECK}
-                name="unmonitored"
-                value={unmonitored}
-                helpText={translate('ICalIncludeUnmonitoredMoviesHelpText')}
-                onChange={this.onInputChange}
-              />
-            </FormGroup>
-
-            <FormGroup>
-              <FormLabel>{translate('ICalShowAsAllDayEvents')}</FormLabel>
-
-              <FormInputGroup
-                type={inputTypes.CHECK}
-                name="asAllDay"
-                value={asAllDay}
-                helpText={translate('ICalShowAsAllDayEventsHelpText')}
-                onChange={this.onInputChange}
-              />
-            </FormGroup>
-
-            <FormGroup>
-              <FormLabel>{translate('Tags')}</FormLabel>
-
-              <FormInputGroup
-                type={inputTypes.TAG}
-                name="tags"
-                value={tags}
-                helpText={translate('ICalTagsMoviesHelpText')}
-                onChange={this.onInputChange}
-              />
-            </FormGroup>
-
-            <FormGroup
-              size={sizes.LARGE}
-            >
-              <FormLabel>{translate('ICalFeed')}</FormLabel>
-
-              <FormInputGroup
-                type={inputTypes.TEXT}
-                name="iCalHttpUrl"
-                value={iCalHttpUrl}
-                readOnly={true}
-                helpText={translate('ICalFeedHelpText')}
-                buttons={[
-                  <ClipboardButton
-                    key="copy"
-                    value={iCalHttpUrl}
-                    kind={kinds.DEFAULT}
-                  />,
-
-                  <FormInputButton
-                    key="webcal"
-                    kind={kinds.DEFAULT}
-                    to={iCalWebCalUrl}
-                    target="_blank"
-                    noRouter={true}
-                  >
-                    <Icon name={icons.CALENDAR_O} />
-                  </FormInputButton>
-                ]}
-                onChange={this.onInputChange}
-                onFocus={this.onLinkFocus}
-              />
-            </FormGroup>
-          </Form>
-        </ModalBody>
-
-        <ModalFooter>
-          <Button onPress={onModalClose}>
-            {translate('Close')}
-          </Button>
-        </ModalFooter>
-      </ModalContent>
-    );
-  }
-}
-
-CalendarLinkModalContent.propTypes = {
-  tagList: PropTypes.arrayOf(PropTypes.object).isRequired,
-  onModalClose: PropTypes.func.isRequired
-};
-
-export default CalendarLinkModalContent;

frontend/src/Calendar/iCal/CalendarLinkModalContent.tsx

@@ -0,0 +1,196 @@
+import React, { FocusEvent, useCallback, useMemo, useState } from 'react';
+import Form from 'Components/Form/Form';
+import FormGroup from 'Components/Form/FormGroup';
+import FormInputButton from 'Components/Form/FormInputButton';
+import FormInputGroup from 'Components/Form/FormInputGroup';
+import FormLabel from 'Components/Form/FormLabel';
+import { EnhancedSelectInputValue } from 'Components/Form/Select/EnhancedSelectInput';
+import Icon from 'Components/Icon';
+import Button from 'Components/Link/Button';
+import ClipboardButton from 'Components/Link/ClipboardButton';
+import ModalBody from 'Components/Modal/ModalBody';
+import ModalContent from 'Components/Modal/ModalContent';
+import ModalFooter from 'Components/Modal/ModalFooter';
+import ModalHeader from 'Components/Modal/ModalHeader';
+import { icons, inputTypes, kinds, sizes } from 'Helpers/Props';
+import { InputChanged } from 'typings/inputs';
+import translate from 'Utilities/String/translate';
+
+const releaseTypeOptions: EnhancedSelectInputValue<string>[] = [
+  {
+    key: 'cinemaRelease',
+    get value() {
+      return translate('CinemaRelease');
+    },
+  },
+  {
+    key: 'digitalRelease',
+    get value() {
+      return translate('DigitalRelease');
+    },
+  },
+  {
+    key: 'physicalRelease',
+    get value() {
+      return translate('PhysicalRelease');
+    },
+  },
+];
+
+interface CalendarLinkModalContentProps {
+  onModalClose: () => void;
+}
+
+function CalendarLinkModalContent({
+  onModalClose,
+}: CalendarLinkModalContentProps) {
+  const [state, setState] = useState<{
+    unmonitored: boolean;
+    asAllDay: boolean;
+    releaseTypes: string[];
+    tags: number[];
+  }>({
+    unmonitored: false,
+    asAllDay: false,
+    releaseTypes: [],
+    tags: [],
+  });
+
+  const { unmonitored, asAllDay, releaseTypes, tags } = state;
+
+  const handleInputChange = useCallback(({ name, value }: InputChanged) => {
+    setState((prevState) => ({ ...prevState, [name]: value }));
+  }, []);
+
+  const handleLinkFocus = useCallback(
+    (event: FocusEvent<HTMLInputElement, Element>) => {
+      event.target.select();
+    },
+    []
+  );
+
+  const { iCalHttpUrl, iCalWebCalUrl } = useMemo(() => {
+    let icalUrl = `${window.location.host}${window.Radarr.urlBase}/feed/v3/calendar/Radarr.ics?`;
+
+    if (unmonitored) {
+      icalUrl += 'unmonitored=true&';
+    }
+
+    if (asAllDay) {
+      icalUrl += 'asAllDay=true&';
+    }
+
+    if (releaseTypes.length) {
+      releaseTypes.forEach((releaseType) => {
+        icalUrl += `releaseTypes=${releaseType}&`;
+      });
+    }
+
+    if (tags.length) {
+      icalUrl += `tags=${tags.toString()}&`;
+    }
+
+    icalUrl += `apikey=${encodeURIComponent(window.Radarr.apiKey)}`;
+
+    return {
+      iCalHttpUrl: `${window.location.protocol}//${icalUrl}`,
+      iCalWebCalUrl: `webcal://${icalUrl}`,
+    };
+  }, [unmonitored, asAllDay, releaseTypes, tags]);
+
+  return (
+    <ModalContent onModalClose={onModalClose}>
+      <ModalHeader>{translate('CalendarFeed')}</ModalHeader>
+
+      <ModalBody>
+        <Form>
+          <FormGroup>
+            <FormLabel>{translate('IncludeUnmonitored')}</FormLabel>
+
+            <FormInputGroup
+              type={inputTypes.CHECK}
+              name="unmonitored"
+              value={unmonitored}
+              helpText={translate('ICalIncludeUnmonitoredMoviesHelpText')}
+              onChange={handleInputChange}
+            />
+          </FormGroup>
+
+          <FormGroup>
+            <FormLabel>{translate('ICalShowAsAllDayEvents')}</FormLabel>
+
+            <FormInputGroup
+              type={inputTypes.CHECK}
+              name="asAllDay"
+              value={asAllDay}
+              helpText={translate('ICalShowAsAllDayEventsHelpText')}
+              onChange={handleInputChange}
+            />
+          </FormGroup>
+
+          <FormGroup>
+            <FormLabel>{translate('ICalReleaseTypes')}</FormLabel>
+
+            <FormInputGroup
+              type={inputTypes.SELECT}
+              name="releaseTypes"
+              value={releaseTypes}
+              values={releaseTypeOptions}
+              helpText={translate('ICalReleaseTypesMoviesHelpText')}
+              onChange={handleInputChange}
+            />
+          </FormGroup>
+
+          <FormGroup>
+            <FormLabel>{translate('Tags')}</FormLabel>
+
+            <FormInputGroup
+              type={inputTypes.MOVIE_TAG}
+              name="tags"
+              value={tags}
+              helpText={translate('ICalTagsMoviesHelpText')}
+              onChange={handleInputChange}
+            />
+          </FormGroup>
+
+          <FormGroup size={sizes.LARGE}>
+            <FormLabel>{translate('ICalFeed')}</FormLabel>
+
+            <FormInputGroup
+              type={inputTypes.TEXT}
+              name="iCalHttpUrl"
+              value={iCalHttpUrl}
+              readOnly={true}
+              helpText={translate('ICalFeedHelpText')}
+              buttons={[
+                <ClipboardButton
+                  key="copy"
+                  value={iCalHttpUrl}
+                  kind={kinds.DEFAULT}
+                />,
+
+                <FormInputButton
+                  key="webcal"
+                  kind={kinds.DEFAULT}
+                  to={iCalWebCalUrl}
+                  target="_blank"
+                  noRouter={true}
+                >
+                  <Icon name={icons.CALENDAR_O} />
+                </FormInputButton>,
+              ]}
+              onChange={handleInputChange}
+              onFocus={handleLinkFocus}
+            />
+          </FormGroup>
+        </Form>
+      </ModalBody>
+
+      <ModalFooter>
+        <Button onPress={onModalClose}>{translate('Close')}</Button>
+      </ModalFooter>
+    </ModalContent>
+  );
+}
+
+export default CalendarLinkModalContent;

frontend/src/Calendar/iCal/CalendarLinkModalContentConnector.js

@@ -1,17 +0,0 @@
-import { connect } from 'react-redux';
-import { createSelector } from 'reselect';
-import createTagsSelector from 'Store/Selectors/createTagsSelector';
-import CalendarLinkModalContent from './CalendarLinkModalContent';
-
-function createMapStateToProps() {
-  return createSelector(
-    createTagsSelector(),
-    (tagList) => {
-      return {
-        tagList
-      };
-    }
-  );
-}
-
-export default connect(createMapStateToProps)(CalendarLinkModalContent);

frontend/src/Collection/AddNewMovieCollectionMovieModal.tsx

@@ -1,6 +1,7 @@
-import React, { useCallback } from 'react';
+import React, { useCallback, useEffect } from 'react';
 import { useDispatch } from 'react-redux';
 import Modal from 'Components/Modal/Modal';
+import usePrevious from 'Helpers/Hooks/usePrevious';
 import { clearPendingChanges } from 'Store/Actions/baseActions';
 import AddNewMovieCollectionMovieModalContent, {
   AddNewMovieCollectionMovieModalContentProps,
@@ -18,11 +19,19 @@ function AddNewMovieCollectionMovieModal({
 }: AddNewCollectionMovieModalProps) {
   const dispatch = useDispatch();
 
+  const wasOpen = usePrevious(isOpen);
+
   const handleModalClose = useCallback(() => {
     dispatch(clearPendingChanges({ section: 'movieCollections' }));
     onModalClose();
   }, [dispatch, onModalClose]);
 
+  useEffect(() => {
+    if (wasOpen && !isOpen) {
+      dispatch(clearPendingChanges({ section: 'movieCollections' }));
+    }
+  }, [wasOpen, isOpen, dispatch]);
+
   return (
     <Modal isOpen={isOpen} onModalClose={handleModalClose}>
       <AddNewMovieCollectionMovieModalContent

frontend/src/Collection/Collection.js

@@ -224,6 +224,7 @@ class Collection extends Component {
       view,
       onSortSelect,
       onFilterSelect,
+      initialScrollTop,
       onScroll,
       isRefreshingCollections,
       isSaving,
@@ -247,7 +248,7 @@ class Collection extends Component {
     const hasNoCollection = !totalItems;
 
     return (
-      <PageContent>
+      <PageContent title={translate('Collections')}>
         <PageToolbar>
           <PageToolbarSection>
             <PageToolbarButton
@@ -306,6 +307,7 @@ class Collection extends Component {
             ref={this.scrollerRef}
             className={styles.contentBody}
             innerClassName={styles[`${view}InnerContentBody`]}
+            onScroll={onScroll}
           >
             {
               isFetching && !isPopulated &&
@@ -334,6 +336,7 @@ class Collection extends Component {
                     onSelectedChange={this.onSelectedChange}
                     onSelectAllChange={this.onSelectAllChange}
                     selectedState={selectedState}
+                    scrollTop={initialScrollTop}
                     {...otherProps}
                   />
                 </div>
@@ -374,6 +377,7 @@ class Collection extends Component {
 }
 
 Collection.propTypes = {
+  initialScrollTop: PropTypes.number,
   isFetching: PropTypes.bool.isRequired,
   isPopulated: PropTypes.bool.isRequired,
   isSaving: PropTypes.bool.isRequired,

frontend/src/Collection/CollectionConnector.js

@@ -5,14 +5,17 @@ import { createSelector } from 'reselect';
 import * as commandNames from 'Commands/commandNames';
 import withScrollPosition from 'Components/withScrollPosition';
 import { executeCommand } from 'Store/Actions/commandActions';
-import { saveMovieCollections, setMovieCollectionsFilter, setMovieCollectionsSort } from 'Store/Actions/movieCollectionActions';
+import {
+  fetchMovieCollections,
+  saveMovieCollections,
+  setMovieCollectionsFilter,
+  setMovieCollectionsSort
+} from 'Store/Actions/movieCollectionActions';
 import { clearQueueDetails, fetchQueueDetails } from 'Store/Actions/queueActions';
-import { fetchRootFolders } from 'Store/Actions/rootFolderActions';
 import scrollPositions from 'Store/scrollPositions';
 import createCollectionClientSideCollectionItemsSelector from 'Store/Selectors/createCollectionClientSideCollectionItemsSelector';
 import createCommandExecutingSelector from 'Store/Selectors/createCommandExecutingSelector';
 import createDimensionsSelector from 'Store/Selectors/createDimensionsSelector';
-import { registerPagePopulator, unregisterPagePopulator } from 'Utilities/pagePopulator';
 import Collection from './Collection';
 
 function createMapStateToProps() {
@@ -36,8 +39,8 @@ function createMapStateToProps() {
 
 function createMapDispatchToProps(dispatch, props) {
   return {
-    dispatchFetchRootFolders() {
-      dispatch(fetchRootFolders());
+    dispatchFetchMovieCollections() {
+      dispatch(fetchMovieCollections());
     },
     dispatchFetchQueueDetails() {
       dispatch(fetchQueueDetails());
@@ -68,13 +71,11 @@ class CollectionConnector extends Component {
   // Lifecycle
 
   componentDidMount() {
-    registerPagePopulator(this.repopulate);
-    this.props.dispatchFetchRootFolders();
+    this.props.dispatchFetchMovieCollections();
     this.props.dispatchFetchQueueDetails();
   }
 
   componentWillUnmount() {
-    unregisterPagePopulator(this.repopulate);
     this.props.dispatchClearQueueDetails();
   }
 
@@ -93,9 +94,16 @@ class CollectionConnector extends Component {
   // Render
 
   render() {
+    const {
+      dispatchFetchMovieCollections,
+      dispatchFetchQueueDetails,
+      dispatchClearQueueDetails,
+      ...otherProps
+    } = this.props;
+
     return (
       <Collection
-        {...this.props}
+        {...otherProps}
         onViewSelect={this.onViewSelect}
         onScroll={this.onScroll}
         onUpdateSelectedPress={this.onUpdateSelectedPress}
@@ -108,7 +116,7 @@ CollectionConnector.propTypes = {
   isSmallScreen: PropTypes.bool.isRequired,
   view: PropTypes.string.isRequired,
   onUpdateSelectedPress: PropTypes.func.isRequired,
-  dispatchFetchRootFolders: PropTypes.func.isRequired,
+  dispatchFetchMovieCollections: PropTypes.func.isRequired,
   dispatchFetchQueueDetails: PropTypes.func.isRequired,
   dispatchClearQueueDetails: PropTypes.func.isRequired
 };

frontend/src/Collection/Overview/CollectionMovie.css

@@ -9,12 +9,13 @@ $hoverScale: 1.05;
     box-shadow: 0 0 10px var(--black);
     transition: all 200ms ease-in;
 
-    .poster {
+    .poster,
+    .overlayTitle {
       opacity: 0.5;
       transition: opacity 100ms linear 100ms;
     }
 
-    .overlayTitle {
+    .overlayHoverTitle {
       opacity: 1;
       transition: opacity 100ms linear 100ms;
     }
@@ -31,7 +32,22 @@ $hoverScale: 1.05;
   background-color: var(--defaultColor);
 }
 
-.overlay {
+.overlayTitle {
+  position: absolute;
+  top: 0;
+  left: 0;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  padding: 5px;
+  width: 100%;
+  height: 100%;
+  color: var(--offWhite);
+  text-align: center;
+  font-size: 20px;
+}
+
+.overlayHover {
   position: absolute;
   top: 0;
   left: 0;
@@ -42,10 +58,10 @@ $hoverScale: 1.05;
   height: 100%;
 }
 
-.overlayTitle {
+.overlayHoverTitle {
   padding: 5px;
   color: var(--offWhite);
-  text-align: left;
+  text-align: center;
   font-weight: bold;
   font-size: 15px;
   opacity: 0;

frontend/src/Collection/Overview/CollectionMovie.css.d.ts

@@ -10,7 +10,8 @@ interface CssExports {
   'externalLinks': string;
   'link': string;
   'monitorToggleButton': string;
-  'overlay': string;
+  'overlayHover': string;
+  'overlayHoverTitle': string;
   'overlayTitle': string;
   'poster': string;
   'posterContainer': string;

frontend/src/Collection/Overview/CollectionMovie.js

@@ -82,6 +82,7 @@ class CollectionMovie extends Component {
     } = this.props;
 
     const {
+      hasPosterError,
       isEditMovieModalOpen,
       isNewAddMovieModalOpen
     } = this.state;
@@ -134,26 +135,31 @@ class CollectionMovie extends Component {
               onLoad={this.onPosterLoad}
             />
 
-            <div className={styles.overlay}>
-              <div className={styles.overlayTitle}>
+            {
+              hasPosterError &&
+                <div className={styles.overlayTitle}>
+                  {title}
+                </div>
+            }
+
+            <div className={styles.overlayHover}>
+              <div className={styles.overlayHoverTitle}>
                 {title} {year > 0 ? `(${year})` : ''}
               </div>
 
               {
                 id ?
-                  <div className={styles.overlayStatus}>
-                    <MovieIndexProgressBar
-                      movieId={id}
-                      movieFile={movieFile}
-                      monitored={monitored}
-                      hasFile={hasFile}
-                      status={status}
-                      bottomRadius={true}
-                      width={posterWidth}
-                      detailedProgressBar={detailedProgressBar}
-                      isAvailable={isAvailable}
-                    />
-                  </div> :
+                  <MovieIndexProgressBar
+                    movieId={id}
+                    movieFile={movieFile}
+                    monitored={monitored}
+                    hasFile={hasFile}
+                    status={status}
+                    bottomRadius={true}
+                    width={posterWidth}
+                    detailedProgressBar={detailedProgressBar}
+                    isAvailable={isAvailable}
+                  /> :
                   null
               }
             </div>

frontend/src/Collection/Overview/CollectionOverview.js

@@ -196,7 +196,7 @@ class CollectionOverview extends Component {
                       size={13}
                     />
                     <span className={styles.status}>
-                      {`${missingMovies} missing movie(s)`}
+                      {translate('CountMissingMoviesFromLibrary', { count: missingMovies })}
                     </span>
                   </Label>
 

frontend/src/Collection/Overview/CollectionOverviews.js

@@ -14,17 +14,17 @@ const columnPadding = parseInt(dimensions.movieIndexColumnPadding);
 const columnPaddingSmallScreen = parseInt(dimensions.movieIndexColumnPaddingSmallScreen);
 
 function calculatePosterWidth(posterSize, isSmallScreen) {
-  const maxiumPosterWidth = isSmallScreen ? 152 : 162;
+  const maximumPosterWidth = isSmallScreen ? 152 : 162;
 
   if (posterSize === 'large') {
-    return maxiumPosterWidth;
+    return maximumPosterWidth;
   }
 
   if (posterSize === 'medium') {
-    return Math.floor(maxiumPosterWidth * 0.75);
+    return Math.floor(maximumPosterWidth * 0.75);
   }
 
-  return Math.floor(maxiumPosterWidth * 0.5);
+  return Math.floor(maximumPosterWidth * 0.5);
 }
 
 function calculateRowHeight(posterHeight, sortKey, isSmallScreen, overviewOptions) {
@@ -92,15 +92,14 @@ class CollectionOverviews extends Component {
 
     if (this._grid && scrollTop !== 0 && !scrollRestored) {
       this.setState({ scrollRestored: true });
-      this._grid.scrollToPosition({ scrollTop });
+      this._gridScrollToPosition({ scrollTop });
     }
 
     if (jumpToCharacter != null && jumpToCharacter !== prevProps.jumpToCharacter) {
       const index = getIndexOfFirstCharacter(items, jumpToCharacter);
 
       if (this._grid && index != null) {
-
-        this._grid.scrollToCell({
+        this._gridScrollToCell({
           rowIndex: index,
           columnIndex: 0
         });
@@ -186,6 +185,19 @@ class CollectionOverviews extends Component {
     );
   };
 
+  _gridScrollToCell = ({ rowIndex = 0, columnIndex = 0 }) => {
+    const scrollOffset = this._grid.getOffsetForCell({
+      rowIndex,
+      columnIndex
+    });
+
+    this._gridScrollToPosition(scrollOffset);
+  };
+
+  _gridScrollToPosition = ({ scrollTop = 0, scrollLeft = 0 }) => {
+    this.props.scroller?.scrollTo({ top: scrollTop, left: scrollLeft });
+  };
+
   //
   // Listeners
 

frontend/src/Components/Form/Form.tsx

@@ -5,18 +5,20 @@ import { ValidationError, ValidationWarning } from 'typings/pending';
 import styles from './Form.css';
 
 export interface FormProps {
+  id?: string;
   children: ReactNode;
   validationErrors?: ValidationError[];
   validationWarnings?: ValidationWarning[];
 }
 
 function Form({
+  id,
   children,
   validationErrors = [],
   validationWarnings = [],
 }: FormProps) {
   return (
-    <div>
+    <div id={id}>
       {validationErrors.length || validationWarnings.length ? (
         <div className={styles.validationFailures}>
           {validationErrors.map((error, index) => {

frontend/src/Components/Form/FormInputButton.tsx

@@ -8,12 +8,14 @@ import styles from './FormInputButton.css';
 export interface FormInputButtonProps extends ButtonProps {
   canSpin?: boolean;
   isLastButton?: boolean;
+  isSpinning?: boolean;
 }
 
 function FormInputButton({
   className = styles.button,
   canSpin = false,
   isLastButton = true,
+  isSpinning = false,
   kind = kinds.PRIMARY,
   ...otherProps
 }: FormInputButtonProps) {
@@ -22,6 +24,7 @@ function FormInputButton({
       <SpinnerButton
         className={classNames(className, !isLastButton && styles.middleButton)}
         kind={kind}
+        isSpinning={isSpinning}
         {...otherProps}
       />
     );

frontend/src/Components/Form/Select/EnhancedSelectInput.tsx

@@ -13,11 +13,11 @@ import { Manager, Popper, Reference } from 'react-popper';
 import Icon from 'Components/Icon';
 import Link from 'Components/Link/Link';
 import LoadingIndicator from 'Components/Loading/LoadingIndicator';
-import Measure from 'Components/Measure';
 import Modal from 'Components/Modal/Modal';
 import ModalBody from 'Components/Modal/ModalBody';
 import Portal from 'Components/Portal';
 import Scroller from 'Components/Scroller/Scroller';
+import useMeasure from 'Helpers/Hooks/useMeasure';
 import { icons } from 'Helpers/Props';
 import ArrayElement from 'typings/Helpers/ArrayElement';
 import { EnhancedSelectInputChanged, InputChanged } from 'typings/inputs';
@@ -162,13 +162,13 @@ function EnhancedSelectInput<T extends EnhancedSelectInputValue<V>, V>(
     onOpen,
   } = props;
 
+  const [measureRef, { width }] = useMeasure();
   const updater = useRef<(() => void) | null>(null);
   const buttonId = useMemo(() => getUniqueElementId(), []);
   const optionsId = useMemo(() => getUniqueElementId(), []);
   const [selectedIndex, setSelectedIndex] = useState(
     getSelectedIndex(value, values)
   );
-  const [width, setWidth] = useState(0);
   const [isOpen, setIsOpen] = useState(false);
   const isMobile = useMemo(() => isMobileUtil(), []);
 
@@ -378,13 +378,6 @@ function EnhancedSelectInput<T extends EnhancedSelectInputValue<V>, V>(
     ]
   );
 
-  const handleMeasure = useCallback(
-    ({ width: newWidth }: { width: number }) => {
-      setWidth(newWidth);
-    },
-    [setWidth]
-  );
-
   const handleOptionsModalClose = useCallback(() => {
     setIsOpen(false);
   }, [setIsOpen]);
@@ -418,7 +411,7 @@ function EnhancedSelectInput<T extends EnhancedSelectInputValue<V>, V>(
         <Reference>
           {({ ref }) => (
             <div ref={ref} id={buttonId}>
-              <Measure whitelist={['width']} onMeasure={handleMeasure}>
+              <div ref={measureRef}>
                 {isEditable && typeof value === 'string' ? (
                   <div className={styles.editableContainer}>
                     <TextInput
@@ -492,7 +485,7 @@ function EnhancedSelectInput<T extends EnhancedSelectInputValue<V>, V>(
                     </div>
                   </Link>
                 )}
-              </Measure>
+              </div>
             </div>
           )}
         </Reference>

frontend/src/Components/Form/Select/QualityProfileSelectInput.tsx

@@ -18,7 +18,7 @@ function createQualityProfilesSelector(
   includeMixed: boolean
 ) {
   return createSelector(
-    createSortedSectionSelector(
+    createSortedSectionSelector<QualityProfile, QualityProfilesAppState>(
       'settings.qualityProfiles',
       sortByProp<QualityProfile, 'name'>('name')
     ),
@@ -88,13 +88,10 @@ function QualityProfileSelectInput({
   );
 
   const handleChange = useCallback(
-    ({ value: newValue }: EnhancedSelectInputChanged<string | number>) => {
-      onChange({
-        name,
-        value: newValue === 'noChange' ? value : newValue,
-      });
+    ({ value }: EnhancedSelectInputChanged<string | number>) => {
+      onChange({ name, value });
     },
-    [name, value, onChange]
+    [name, onChange]
   );
 
   useEffect(() => {

frontend/src/Components/Form/Tag/TagInput.tsx

@@ -14,7 +14,7 @@ import {
   RenderSuggestion,
   SuggestionsFetchRequestedParams,
 } from 'react-autosuggest';
-import useDebouncedCallback from 'Helpers/Hooks/useDebouncedCallback';
+import { useDebouncedCallback } from 'use-debounce';
 import { Kind } from 'Helpers/Props/kinds';
 import { InputChanged } from 'typings/inputs';
 import AutoSuggestInput from '../AutoSuggestInput';

frontend/src/Components/ImportListList.js

@@ -1,43 +0,0 @@
-import _ from 'lodash';
-import PropTypes from 'prop-types';
-import React from 'react';
-import { kinds, sizes } from 'Helpers/Props';
-import Label from './Label';
-import styles from './ImportListList.css';
-
-function ImportListList({ lists, importListList }) {
-  return (
-    <div className={styles.lists}>
-      {
-        lists.map((t) => {
-          const list = _.find(importListList, { id: t });
-
-          if (!list) {
-            return null;
-          }
-
-          return (
-            <Label
-              key={list.id}
-              kind={kinds.SUCCESS}
-              size={sizes.MEDIUM}
-            >
-              {list.name}
-            </Label>
-          );
-        })
-      }
-    </div>
-  );
-}
-
-ImportListList.propTypes = {
-  lists: PropTypes.arrayOf(PropTypes.number).isRequired,
-  importListList: PropTypes.arrayOf(PropTypes.object).isRequired
-};
-
-ImportListList.defaultProps = {
-  lists: []
-};
-
-export default ImportListList;

frontend/src/Components/ImportListList.tsx

@@ -0,0 +1,35 @@
+import React from 'react';
+import { useSelector } from 'react-redux';
+import AppState from 'App/State/AppState';
+import Label from './Label';
+import styles from './ImportListList.css';
+
+interface ImportListListProps {
+  lists: number[];
+}
+
+function ImportListList({ lists }: ImportListListProps) {
+  const allImportLists = useSelector(
+    (state: AppState) => state.settings.importLists.items
+  );
+
+  return (
+    <div className={styles.lists}>
+      {lists.map((id) => {
+        const importList = allImportLists.find((list) => list.id === id);
+
+        if (!importList) {
+          return null;
+        }
+
+        return (
+          <Label key={importList.id} kind="success" size="medium">
+            {importList.name}
+          </Label>
+        );
+      })}
+    </div>
+  );
+}
+
+export default ImportListList;

frontend/src/Components/ImportListListConnector.js

@@ -1,17 +0,0 @@
-import { connect } from 'react-redux';
-import { createSelector } from 'reselect';
-import createImportListSelector from 'Store/Selectors/createImportListSelector';
-import ImportListList from './ImportListList';
-
-function createMapStateToProps() {
-  return createSelector(
-    createImportListSelector(),
-    (importListList) => {
-      return {
-        importListList
-      };
-    }
-  );
-}
-
-export default connect(createMapStateToProps)(ImportListList);

frontend/src/Components/Link/Button.tsx

@@ -1,16 +1,14 @@
 import classNames from 'classnames';
 import React from 'react';
-import { align, kinds, sizes } from 'Helpers/Props';
+import { kinds, sizes } from 'Helpers/Props';
+import { Align } from 'Helpers/Props/align';
 import { Kind } from 'Helpers/Props/kinds';
 import { Size } from 'Helpers/Props/sizes';
 import Link, { LinkProps } from './Link';
 import styles from './Button.css';
 
 export interface ButtonProps extends Omit<LinkProps, 'children' | 'size'> {
-  buttonGroupPosition?: Extract<
-    (typeof align.all)[number],
-    keyof typeof styles
-  >;
+  buttonGroupPosition?: Extract<Align, keyof typeof styles>;
   kind?: Extract<Kind, keyof typeof styles>;
   size?: Extract<Size, keyof typeof styles>;
   children: Required<LinkProps['children']>;

frontend/src/Components/Link/SpinnerButton.js

@@ -1,58 +0,0 @@
-import classNames from 'classnames';
-import PropTypes from 'prop-types';
-import React from 'react';
-import Icon from 'Components/Icon';
-import { icons } from 'Helpers/Props';
-import Button from './Button';
-import styles from './SpinnerButton.css';
-
-function SpinnerButton(props) {
-  const {
-    className,
-    isSpinning,
-    isDisabled,
-    spinnerIcon,
-    children,
-    ...otherProps
-  } = props;
-
-  return (
-    <Button
-      className={classNames(
-        className,
-        styles.button,
-        isSpinning && styles.isSpinning
-      )}
-      isDisabled={isDisabled || isSpinning}
-      {...otherProps}
-    >
-      <span className={styles.spinnerContainer}>
-        <Icon
-          className={styles.spinner}
-          name={spinnerIcon}
-          isSpinning={true}
-        />
-      </span>
-
-      <span className={styles.label}>
-        {children}
-      </span>
-    </Button>
-  );
-}
-
-SpinnerButton.propTypes = {
-  ...Button.Props,
-  className: PropTypes.string.isRequired,
-  isSpinning: PropTypes.bool.isRequired,
-  isDisabled: PropTypes.bool,
-  spinnerIcon: PropTypes.object.isRequired,
-  children: PropTypes.node
-};
-
-SpinnerButton.defaultProps = {
-  className: styles.button,
-  spinnerIcon: icons.SPINNER
-};
-
-export default SpinnerButton;

frontend/src/Components/Link/SpinnerButton.tsx

@@ -0,0 +1,41 @@
+import classNames from 'classnames';
+import React from 'react';
+import Icon, { IconName } from 'Components/Icon';
+import { icons } from 'Helpers/Props';
+import Button, { ButtonProps } from './Button';
+import styles from './SpinnerButton.css';
+
+export interface SpinnerButtonProps extends ButtonProps {
+  isSpinning: boolean;
+  isDisabled?: boolean;
+  spinnerIcon?: IconName;
+}
+
+function SpinnerButton({
+  className = styles.button,
+  isSpinning,
+  isDisabled,
+  spinnerIcon = icons.SPINNER,
+  children,
+  ...otherProps
+}: SpinnerButtonProps) {
+  return (
+    <Button
+      className={classNames(
+        className,
+        styles.button,
+        isSpinning && styles.isSpinning
+      )}
+      isDisabled={isDisabled || isSpinning}
+      {...otherProps}
+    >
+      <span className={styles.spinnerContainer}>
+        <Icon className={styles.spinner} name={spinnerIcon} isSpinning={true} />
+      </span>
+
+      <span className={styles.label}>{children}</span>
+    </Button>
+  );
+}
+
+export default SpinnerButton;

frontend/src/Components/Link/SpinnerErrorButton.js

@@ -1,165 +0,0 @@
-import _ from 'lodash';
-import PropTypes from 'prop-types';
-import React, { Component } from 'react';
-import Icon from 'Components/Icon';
-import SpinnerButton from 'Components/Link/SpinnerButton';
-import { icons, kinds } from 'Helpers/Props';
-import styles from './SpinnerErrorButton.css';
-
-function getTestResult(error) {
-  if (!error) {
-    return {
-      wasSuccessful: true,
-      hasWarning: false,
-      hasError: false
-    };
-  }
-
-  if (error.status !== 400) {
-    return {
-      wasSuccessful: false,
-      hasWarning: false,
-      hasError: true
-    };
-  }
-
-  const failures = error.responseJSON;
-
-  const hasWarning = _.some(failures, { isWarning: true });
-  const hasError = _.some(failures, (failure) => !failure.isWarning);
-
-  return {
-    wasSuccessful: false,
-    hasWarning,
-    hasError
-  };
-}
-
-class SpinnerErrorButton extends Component {
-
-  //
-  // Lifecycle
-
-  constructor(props, context) {
-    super(props, context);
-
-    this._testResultTimeout = null;
-
-    this.state = {
-      wasSuccessful: false,
-      hasWarning: false,
-      hasError: false
-    };
-  }
-
-  componentDidUpdate(prevProps) {
-    const {
-      isSpinning,
-      error
-    } = this.props;
-
-    if (prevProps.isSpinning && !isSpinning) {
-      const testResult = getTestResult(error);
-
-      this.setState(testResult, () => {
-        const {
-          wasSuccessful,
-          hasWarning,
-          hasError
-        } = testResult;
-
-        if (wasSuccessful || hasWarning || hasError) {
-          this._testResultTimeout = setTimeout(this.resetState, 3000);
-        }
-      });
-    }
-  }
-
-  componentWillUnmount() {
-    if (this._testResultTimeout) {
-      clearTimeout(this._testResultTimeout);
-    }
-  }
-
-  //
-  // Control
-
-  resetState = () => {
-    this.setState({
-      wasSuccessful: false,
-      hasWarning: false,
-      hasError: false
-    });
-  };
-
-  //
-  // Render
-
-  render() {
-    const {
-      kind,
-      isSpinning,
-      error,
-      children,
-      ...otherProps
-    } = this.props;
-
-    const {
-      wasSuccessful,
-      hasWarning,
-      hasError
-    } = this.state;
-
-    const showIcon = wasSuccessful || hasWarning || hasError;
-
-    let iconName = icons.CHECK;
-    let iconKind = kind === kinds.PRIMARY ? kinds.DEFAULT : kinds.SUCCESS;
-
-    if (hasWarning) {
-      iconName = icons.WARNING;
-      iconKind = kinds.WARNING;
-    }
-
-    if (hasError) {
-      iconName = icons.DANGER;
-      iconKind = kinds.DANGER;
-    }
-
-    return (
-      <SpinnerButton
-        kind={kind}
-        isSpinning={isSpinning}
-        {...otherProps}
-      >
-        <span className={showIcon ? styles.showIcon : undefined}>
-          {
-            showIcon &&
-              <span className={styles.iconContainer}>
-                <Icon
-                  name={iconName}
-                  kind={iconKind}
-                />
-              </span>
-          }
-
-          {
-            <span className={styles.label}>
-              {
-                children
-              }
-            </span>
-          }
-        </span>
-      </SpinnerButton>
-    );
-  }
-}
-
-SpinnerErrorButton.propTypes = {
-  kind: PropTypes.oneOf(kinds.all),
-  isSpinning: PropTypes.bool.isRequired,
-  error: PropTypes.object,
-  children: PropTypes.node.isRequired
-};
-
-export default SpinnerErrorButton;

frontend/src/Components/Link/SpinnerErrorButton.tsx

@@ -0,0 +1,143 @@
+import React, { useEffect, useMemo, useRef, useState } from 'react';
+import { Error } from 'App/State/AppSectionState';
+import Icon, { IconKind, IconName } from 'Components/Icon';
+import SpinnerButton, {
+  SpinnerButtonProps,
+} from 'Components/Link/SpinnerButton';
+import usePrevious from 'Helpers/Hooks/usePrevious';
+import { icons } from 'Helpers/Props';
+import { ValidationFailure } from 'typings/pending';
+import styles from './SpinnerErrorButton.css';
+
+function getTestResult(error: Error | string | undefined) {
+  if (!error) {
+    return {
+      wasSuccessful: true,
+      hasWarning: false,
+      hasError: false,
+    };
+  }
+
+  if (typeof error === 'string' || error.status !== 400) {
+    return {
+      wasSuccessful: false,
+      hasWarning: false,
+      hasError: true,
+    };
+  }
+
+  const failures = error.responseJSON as ValidationFailure[];
+
+  const { hasError, hasWarning } = failures.reduce(
+    (acc, failure) => {
+      if (failure.isWarning) {
+        acc.hasWarning = true;
+      } else {
+        acc.hasError = true;
+      }
+
+      return acc;
+    },
+    { hasWarning: false, hasError: false }
+  );
+
+  return {
+    wasSuccessful: false,
+    hasWarning,
+    hasError,
+  };
+}
+
+interface SpinnerErrorButtonProps extends SpinnerButtonProps {
+  isSpinning: boolean;
+  error?: Error | string;
+  children: React.ReactNode;
+}
+
+function SpinnerErrorButton({
+  kind,
+  isSpinning,
+  error,
+  children,
+  ...otherProps
+}: SpinnerErrorButtonProps) {
+  const wasSpinning = usePrevious(isSpinning);
+  const updateTimeout = useRef<ReturnType<typeof setTimeout>>();
+
+  const [result, setResult] = useState({
+    wasSuccessful: false,
+    hasWarning: false,
+    hasError: false,
+  });
+  const { wasSuccessful, hasWarning, hasError } = result;
+
+  const showIcon = wasSuccessful || hasWarning || hasError;
+
+  const { iconName, iconKind } = useMemo<{
+    iconName: IconName;
+    iconKind: IconKind;
+  }>(() => {
+    if (hasWarning) {
+      return {
+        iconName: icons.WARNING,
+        iconKind: 'warning',
+      };
+    }
+
+    if (hasError) {
+      return {
+        iconName: icons.DANGER,
+        iconKind: 'danger',
+      };
+    }
+
+    return {
+      iconName: icons.CHECK,
+      iconKind: kind === 'primary' ? 'default' : 'success',
+    };
+  }, [kind, hasError, hasWarning]);
+
+  useEffect(() => {
+    if (wasSpinning && !isSpinning) {
+      const testResult = getTestResult(error);
+
+      setResult(testResult);
+
+      const { wasSuccessful, hasWarning, hasError } = testResult;
+
+      if (wasSuccessful || hasWarning || hasError) {
+        updateTimeout.current = setTimeout(() => {
+          setResult({
+            wasSuccessful: false,
+            hasWarning: false,
+            hasError: false,
+          });
+        }, 3000);
+      }
+    }
+  }, [isSpinning, wasSpinning, error]);
+
+  useEffect(() => {
+    return () => {
+      if (updateTimeout.current) {
+        clearTimeout(updateTimeout.current);
+      }
+    };
+  }, []);
+
+  return (
+    <SpinnerButton kind={kind} isSpinning={isSpinning} {...otherProps}>
+      <span className={showIcon ? styles.showIcon : undefined}>
+        {showIcon && (
+          <span className={styles.iconContainer}>
+            <Icon name={iconName} kind={iconKind} />
+          </span>
+        )}
+
+        <span className={styles.label}>{children}</span>
+      </span>
+    </SpinnerButton>
+  );
+}
+
+export default SpinnerErrorButton;

frontend/src/Components/Link/SpinnerIconButton.js

@@ -1,40 +0,0 @@
-import PropTypes from 'prop-types';
-import React from 'react';
-import { icons } from 'Helpers/Props';
-import IconButton from './IconButton';
-
-function SpinnerIconButton(props) {
-  const {
-    name,
-    spinningName,
-    isDisabled,
-    isSpinning,
-    ...otherProps
-  } = props;
-
-  return (
-    <IconButton
-      name={isSpinning ? (spinningName || name) : name}
-      isDisabled={isDisabled || isSpinning}
-      isSpinning={isSpinning}
-      {...otherProps}
-    />
-  );
-}
-
-SpinnerIconButton.propTypes = {
-  ...IconButton.propTypes,
-  className: PropTypes.string,
-  name: PropTypes.object.isRequired,
-  spinningName: PropTypes.object.isRequired,
-  isDisabled: PropTypes.bool.isRequired,
-  isSpinning: PropTypes.bool.isRequired
-};
-
-SpinnerIconButton.defaultProps = {
-  spinningName: icons.SPINNER,
-  isDisabled: false,
-  isSpinning: false
-};
-
-export default SpinnerIconButton;

frontend/src/Components/Link/SpinnerIconButton.tsx

@@ -0,0 +1,27 @@
+import React from 'react';
+import { IconName } from 'Components/Icon';
+import { icons } from 'Helpers/Props';
+import IconButton, { IconButtonProps } from './IconButton';
+
+interface SpinnerIconButtonProps extends IconButtonProps {
+  spinningName?: IconName;
+}
+
+function SpinnerIconButton({
+  name,
+  spinningName = icons.SPINNER,
+  isDisabled = false,
+  isSpinning = false,
+  ...otherProps
+}: SpinnerIconButtonProps) {
+  return (
+    <IconButton
+      name={isSpinning ? spinningName || name : name}
+      isDisabled={isDisabled || isSpinning}
+      isSpinning={isSpinning}
+      {...otherProps}
+    />
+  );
+}
+
+export default SpinnerIconButton;

frontend/src/Components/Menu/FilterMenu.js

@@ -1,112 +0,0 @@
-import PropTypes from 'prop-types';
-import React, { Component } from 'react';
-import { icons } from 'Helpers/Props';
-import translate from 'Utilities/String/translate';
-import FilterMenuContent from './FilterMenuContent';
-import Menu from './Menu';
-import ToolbarMenuButton from './ToolbarMenuButton';
-import styles from './FilterMenu.css';
-
-class FilterMenu extends Component {
-
-  //
-  // Lifecycle
-
-  constructor(props, context) {
-    super(props, context);
-
-    this.state = {
-      isFilterModalOpen: false
-    };
-  }
-
-  //
-  // Listeners
-
-  onCustomFiltersPress = () => {
-    this.setState({ isFilterModalOpen: true });
-  };
-
-  onFiltersModalClose = () => {
-    this.setState({ isFilterModalOpen: false });
-  };
-
-  //
-  // Render
-
-  render(props) {
-    const {
-      className,
-      isDisabled,
-      selectedFilterKey,
-      filters,
-      customFilters,
-      buttonComponent: ButtonComponent,
-      filterModalConnectorComponent: FilterModalConnectorComponent,
-      filterModalConnectorComponentProps,
-      onFilterSelect,
-      ...otherProps
-    } = this.props;
-
-    const showCustomFilters = !!FilterModalConnectorComponent;
-
-    return (
-      <div>
-        <Menu
-          className={className}
-          {...otherProps}
-        >
-          <ButtonComponent
-            iconName={icons.FILTER}
-            showIndicator={selectedFilterKey !== 'all'}
-            text={translate('Filter')}
-            isDisabled={isDisabled}
-          />
-
-          <FilterMenuContent
-            selectedFilterKey={selectedFilterKey}
-            filters={filters}
-            customFilters={customFilters}
-            showCustomFilters={showCustomFilters}
-            onFilterSelect={onFilterSelect}
-            onCustomFiltersPress={this.onCustomFiltersPress}
-          />
-
-        </Menu>
-
-        {
-          showCustomFilters &&
-            <FilterModalConnectorComponent
-              {...filterModalConnectorComponentProps}
-              isOpen={this.state.isFilterModalOpen}
-              selectedFilterKey={selectedFilterKey}
-              filters={filters}
-              customFilters={customFilters}
-              onFilterSelect={onFilterSelect}
-              onModalClose={this.onFiltersModalClose}
-            />
-        }
-      </div>
-    );
-  }
-}
-
-FilterMenu.propTypes = {
-  className: PropTypes.string,
-  isDisabled: PropTypes.bool.isRequired,
-  selectedFilterKey: PropTypes.oneOfType([PropTypes.string, PropTypes.number]).isRequired,
-  filters: PropTypes.arrayOf(PropTypes.object).isRequired,
-  customFilters: PropTypes.arrayOf(PropTypes.object).isRequired,
-  buttonComponent: PropTypes.elementType.isRequired,
-  filterModalConnectorComponent: PropTypes.elementType,
-  filterModalConnectorComponentProps: PropTypes.object,
-  onFilterSelect: PropTypes.func.isRequired
-};
-
-FilterMenu.defaultProps = {
-  className: styles.filterMenu,
-  isDisabled: false,
-  buttonComponent: ToolbarMenuButton
-};
-
-export default FilterMenu;

frontend/src/Components/Menu/FilterMenu.tsx

@@ -0,0 +1,82 @@
+import React, { useCallback, useState } from 'react';
+import { CustomFilter, Filter } from 'App/State/AppState';
+import { icons } from 'Helpers/Props';
+import translate from 'Utilities/String/translate';
+import FilterMenuContent from './FilterMenuContent';
+import Menu from './Menu';
+import ToolbarMenuButton from './ToolbarMenuButton';
+import styles from './FilterMenu.css';
+
+interface FilterMenuProps {
+  className?: string;
+  alignMenu: 'left' | 'right';
+  isDisabled?: boolean;
+  selectedFilterKey: string | number;
+  filters: Filter[];
+  customFilters: CustomFilter[];
+  buttonComponent?: React.ElementType;
+  filterModalConnectorComponent?: React.ElementType;
+  filterModalConnectorComponentProps?: object;
+  onFilterSelect: (filter: number | string) => void;
+}
+
+function FilterMenu({
+  className = styles.filterMenu,
+  isDisabled = false,
+  selectedFilterKey,
+  filters,
+  customFilters,
+  buttonComponent: ButtonComponent = ToolbarMenuButton,
+  filterModalConnectorComponent: FilterModalConnectorComponent,
+  filterModalConnectorComponentProps,
+  onFilterSelect,
+  ...otherProps
+}: FilterMenuProps) {
+  const [isFilterModalOpen, setIsFilterModalOpen] = useState(false);
+
+  const showCustomFilters = !!FilterModalConnectorComponent;
+
+  const handleCustomFiltersPress = useCallback(() => {
+    setIsFilterModalOpen(true);
+  }, []);
+
+  const handleFiltersModalClose = useCallback(() => {
+    setIsFilterModalOpen(false);
+  }, []);
+
+  return (
+    <div>
+      <Menu className={className} {...otherProps}>
+        <ButtonComponent
+          iconName={icons.FILTER}
+          showIndicator={selectedFilterKey !== 'all'}
+          text={translate('Filter')}
+          isDisabled={isDisabled}
+        />
+
+        <FilterMenuContent
+          selectedFilterKey={selectedFilterKey}
+          filters={filters}
+          customFilters={customFilters}
+          showCustomFilters={showCustomFilters}
+          onFilterSelect={onFilterSelect}
+          onCustomFiltersPress={handleCustomFiltersPress}
+        />
+      </Menu>
+
+      {showCustomFilters ? (
+        <FilterModalConnectorComponent
+          {...filterModalConnectorComponentProps}
+          isOpen={isFilterModalOpen}
+          selectedFilterKey={selectedFilterKey}
+          filters={filters}
+          customFilters={customFilters}
+          onFilterSelect={onFilterSelect}
+          onModalClose={handleFiltersModalClose}
+        />
+      ) : null}
+    </div>
+  );
+}
+
+export default FilterMenu;

frontend/src/Components/Menu/FilterMenuContent.js

@@ -1,95 +0,0 @@
-import PropTypes from 'prop-types';
-import React, { Component } from 'react';
-import sortByProp from 'Utilities/Array/sortByProp';
-import translate from 'Utilities/String/translate';
-import FilterMenuItem from './FilterMenuItem';
-import MenuContent from './MenuContent';
-import MenuItem from './MenuItem';
-import MenuItemSeparator from './MenuItemSeparator';
-
-class FilterMenuContent extends Component {
-
-  //
-  // Render
-
-  render() {
-    const {
-      selectedFilterKey,
-      filters,
-      customFilters,
-      showCustomFilters,
-      onFilterSelect,
-      onCustomFiltersPress,
-      ...otherProps
-    } = this.props;
-
-    return (
-      <MenuContent {...otherProps}>
-        {
-          filters.map((filter) => {
-            return (
-              <FilterMenuItem
-                key={filter.key}
-                filterKey={filter.key}
-                selectedFilterKey={selectedFilterKey}
-                onPress={onFilterSelect}
-              >
-                {typeof filter.label === 'function' ? filter.label() : filter.label}
-              </FilterMenuItem>
-            );
-          })
-        }
-
-        {
-          customFilters.length > 0 ?
-            <MenuItemSeparator /> :
-            null
-        }
-
-        {
-          customFilters
-            .sort(sortByProp('label'))
-            .map((filter) => {
-              return (
-                <FilterMenuItem
-                  key={filter.id}
-                  filterKey={filter.id}
-                  selectedFilterKey={selectedFilterKey}
-                  onPress={onFilterSelect}
-                >
-                  {filter.label}
-                </FilterMenuItem>
-              );
-            })
-        }
-
-        {
-          showCustomFilters &&
-            <MenuItemSeparator />
-        }
-
-        {
-          showCustomFilters &&
-            <MenuItem onPress={onCustomFiltersPress}>
-              {translate('CustomFilters')}
-            </MenuItem>
-        }
-      </MenuContent>
-    );
-  }
-}
-
-FilterMenuContent.propTypes = {
-  selectedFilterKey: PropTypes.oneOfType([PropTypes.string, PropTypes.number]).isRequired,
-  filters: PropTypes.arrayOf(PropTypes.object).isRequired,
-  customFilters: PropTypes.arrayOf(PropTypes.object).isRequired,
-  showCustomFilters: PropTypes.bool.isRequired,
-  onFilterSelect: PropTypes.func.isRequired,
-  onCustomFiltersPress: PropTypes.func.isRequired
-};
-
-FilterMenuContent.defaultProps = {
-  showCustomFilters: false
-};
-
-export default FilterMenuContent;