vergnet/application-amicale
5
5
Fork 5
Code Issues Pull requests Releases Wiki Activity

Fix eslint errors

Browse source 
First files rewritten to match the new eslint config
This commit is contained in:
Arnaud Vergnet 2020-08-01 20:59:59 +02:00
parent b596f68abe
commit be1f61b671
4 changed files with 415 additions and 381 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

369
App.js
View file

@ -1,210 +1,211 @@
// @flow // @flow
import * as React from 'react'; import * as React from 'react';
import {LogBox, Platform, SafeAreaView, StatusBar, View} from 'react-native'; import {LogBox, Platform, SafeAreaView, View} from 'react-native';
import LocaleManager from './src/managers/LocaleManager';
import AsyncStorageManager from "./src/managers/AsyncStorageManager";
import CustomIntroSlider from "./src/components/Overrides/CustomIntroSlider";
import type {CustomTheme} from "./src/managers/ThemeManager";
import ThemeManager from './src/managers/ThemeManager';
import {NavigationContainer} from '@react-navigation/native'; import {NavigationContainer} from '@react-navigation/native';
import MainNavigator from './src/navigation/MainNavigator';
import {Provider as PaperProvider} from 'react-native-paper'; import {Provider as PaperProvider} from 'react-native-paper';
import AprilFoolsManager from "./src/managers/AprilFoolsManager"; import {setSafeBounceHeight} from 'react-navigation-collapsible';
import Update from "./src/constants/Update"; import SplashScreen from 'react-native-splash-screen';
import ConnectionManager from "./src/managers/ConnectionManager"; import {OverflowMenuProvider} from 'react-navigation-header-buttons';
import URLHandler from "./src/utils/URLHandler"; import LocaleManager from './src/managers/LocaleManager';
import {setSafeBounceHeight} from "react-navigation-collapsible"; import AsyncStorageManager from './src/managers/AsyncStorageManager';
import SplashScreen from 'react-native-splash-screen' import CustomIntroSlider from './src/components/Overrides/CustomIntroSlider';
import {OverflowMenuProvider} from "react-navigation-header-buttons"; import type {CustomTheme} from './src/managers/ThemeManager';
import ThemeManager from './src/managers/ThemeManager';
import MainNavigator from './src/navigation/MainNavigator';
import AprilFoolsManager from './src/managers/AprilFoolsManager';
import Update from './src/constants/Update';
import ConnectionManager from './src/managers/ConnectionManager';
import type {ParsedUrlDataType} from './src/utils/URLHandler';
import URLHandler from './src/utils/URLHandler';
import {setupStatusBar} from './src/utils/Utils';
// Native optimizations https://reactnavigation.org/docs/react-native-screens // Native optimizations https://reactnavigation.org/docs/react-native-screens
// Crashes app when navigating away from webview on android 9+ // Crashes app when navigating away from webview on android 9+
// enableScreens(true); // enableScreens(true);
LogBox.ignoreLogs([
LogBox.ignoreLogs([ // collapsible headers cause this warning, just ignore as it is not an issue // collapsible headers cause this warning, just ignore as it is not an issue
'Non-serializable values were found in the navigation state', 'Non-serializable values were found in the navigation state',
'Cannot update a component from inside the function body of a different component', 'Cannot update a component from inside the function body of a different component',
]); ]);
type Props = {}; type StateType = {
isLoading: boolean,
type State = { showIntro: boolean,
isLoading: boolean, showUpdate: boolean,
showIntro: boolean, showAprilFools: boolean,
showUpdate: boolean, currentTheme: CustomTheme | null,
showAprilFools: boolean,
currentTheme: CustomTheme | null,
}; };
export default class App extends React.Component<Props, State> { export default class App extends React.Component<null, StateType> {
navigatorRef: {current: null | NavigationContainer};
state = { defaultHomeRoute: string | null;
isLoading: true,
showIntro: true, defaultHomeData: {[key: string]: string};
showUpdate: true,
showAprilFools: false, urlHandler: URLHandler;
currentTheme: null,
constructor() {
super();
this.state = {
isLoading: true,
showIntro: true,
showUpdate: true,
showAprilFools: false,
currentTheme: null,
}; };
LocaleManager.initTranslations();
this.navigatorRef = React.createRef();
this.defaultHomeRoute = null;
this.defaultHomeData = {};
this.urlHandler = new URLHandler(this.onInitialURLParsed, this.onDetectURL);
this.urlHandler.listen();
setSafeBounceHeight(Platform.OS === 'ios' ? 100 : 20);
this.loadAssetsAsync().finally(() => {
this.onLoadFinished();
});
}
navigatorRef: { current: null | NavigationContainer }; /**
* The app has been started by an url, and it has been parsed.
* Set a new default start route based on the data parsed.
*
* @param parsedData The data parsed from the url
*/
onInitialURLParsed = (parsedData: ParsedUrlDataType) => {
this.defaultHomeRoute = parsedData.route;
this.defaultHomeData = parsedData.data;
};
defaultHomeRoute: string | null; /**
defaultHomeData: { [key: string]: any } * An url has been opened and parsed while the app was active.
* Redirect the user to the screen according to parsed data.
createDrawerNavigator: () => React.Node; *
* @param parsedData The data parsed from the url
urlHandler: URLHandler; */
onDetectURL = (parsedData: ParsedUrlDataType) => {
constructor() { // Navigate to nested navigator and pass data to the index screen
super(); const nav = this.navigatorRef.current;
LocaleManager.initTranslations(); if (nav != null) {
this.navigatorRef = React.createRef(); nav.navigate('home', {
this.defaultHomeRoute = null; screen: 'index',
this.defaultHomeData = {}; params: {nextScreen: parsedData.route, data: parsedData.data},
this.urlHandler = new URLHandler(this.onInitialURLParsed, this.onDetectURL); });
this.urlHandler.listen();
setSafeBounceHeight(Platform.OS === 'ios' ? 100 : 20);
this.loadAssetsAsync().then(() => {
this.onLoadFinished();
});
} }
};
/** /**
* The app has been started by an url, and it has been parsed. * Updates the current theme
* Set a new default start route based on the data parsed. */
* onUpdateTheme = () => {
* @param parsedData The data parsed from the url this.setState({
*/ currentTheme: ThemeManager.getCurrentTheme(),
onInitialURLParsed = (parsedData: { route: string, data: { [key: string]: any } }) => { });
this.defaultHomeRoute = parsedData.route; setupStatusBar();
this.defaultHomeData = parsedData.data; };
};
/** /**
* An url has been opened and parsed while the app was active. * Callback when user ends the intro. Save in preferences to avoid showing back the introSlides
* Redirect the user to the screen according to parsed data. */
* onIntroDone = () => {
* @param parsedData The data parsed from the url this.setState({
*/ showIntro: false,
onDetectURL = (parsedData: { route: string, data: { [key: string]: any } }) => { showUpdate: false,
// Navigate to nested navigator and pass data to the index screen showAprilFools: false,
if (this.navigatorRef.current != null) { });
this.navigatorRef.current.navigate('home', { AsyncStorageManager.set(
screen: 'index', AsyncStorageManager.PREFERENCES.showIntro.key,
params: {nextScreen: parsedData.route, data: parsedData.data} false,
}); );
} AsyncStorageManager.set(
}; AsyncStorageManager.PREFERENCES.updateNumber.key,
Update.number,
);
AsyncStorageManager.set(
AsyncStorageManager.PREFERENCES.showAprilFoolsStart.key,
false,
);
};
/** /**
* Updates the current theme * Async loading is done, finish processing startup data
*/ */
onUpdateTheme = () => { onLoadFinished() {
this.setState({ // Only show intro if this is the first time starting the app
currentTheme: ThemeManager.getCurrentTheme() ThemeManager.getInstance().setUpdateThemeCallback(this.onUpdateTheme);
}); // Status bar goes dark if set too fast on ios
this.setupStatusBar(); if (Platform.OS === 'ios') setTimeout(setupStatusBar, 1000);
}; else setupStatusBar();
/** this.setState({
* Updates status bar content color if on iOS only, isLoading: false,
* as the android status bar is always set to black. currentTheme: ThemeManager.getCurrentTheme(),
*/ showIntro: AsyncStorageManager.getBool(
setupStatusBar() { AsyncStorageManager.PREFERENCES.showIntro.key,
if (ThemeManager.getNightMode()) { ),
StatusBar.setBarStyle('light-content', true); showUpdate:
} else { AsyncStorageManager.getNumber(
StatusBar.setBarStyle('dark-content', true); AsyncStorageManager.PREFERENCES.updateNumber.key,
} ) !== Update.number,
if (Platform.OS === "android") showAprilFools:
StatusBar.setBackgroundColor(ThemeManager.getCurrentTheme().colors.surface, true); AprilFoolsManager.getInstance().isAprilFoolsEnabled() &&
AsyncStorageManager.getBool(
AsyncStorageManager.PREFERENCES.showAprilFoolsStart.key,
),
});
SplashScreen.hide();
}
/**
* Loads every async data
*
* @returns {Promise<void>}
*/
loadAssetsAsync = async () => {
await AsyncStorageManager.getInstance().loadPreferences();
await ConnectionManager.getInstance().recoverLogin();
};
/**
* Renders the app based on loading state
*/
render(): React.Node {
const {state} = this;
if (state.isLoading) {
return null;
} }
if (state.showIntro || state.showUpdate || state.showAprilFools) {
/** return (
* Callback when user ends the intro. Save in preferences to avoid showing back the introSlides <CustomIntroSlider
*/ onDone={this.onIntroDone}
onIntroDone = () => { isUpdate={state.showUpdate && !state.showIntro}
this.setState({ isAprilFools={state.showAprilFools && !state.showIntro}
showIntro: false, />
showUpdate: false, );
showAprilFools: false,
});
AsyncStorageManager.set(AsyncStorageManager.PREFERENCES.showIntro.key, false);
AsyncStorageManager.set(AsyncStorageManager.PREFERENCES.updateNumber.key, Update.number);
AsyncStorageManager.set(AsyncStorageManager.PREFERENCES.showAprilFoolsStart.key, false);
};
/**
* Loads every async data
*
* @returns {Promise<void>}
*/
loadAssetsAsync = async () => {
await AsyncStorageManager.getInstance().loadPreferences();
try {
await ConnectionManager.getInstance().recoverLogin();
} catch (e) {
}
}
/**
* Async loading is done, finish processing startup data
*/
onLoadFinished() {
// Only show intro if this is the first time starting the app
this.createDrawerNavigator = () => <MainNavigator
defaultHomeRoute={this.defaultHomeRoute}
defaultHomeData={this.defaultHomeData}
/>;
ThemeManager.getInstance().setUpdateThemeCallback(this.onUpdateTheme);
// Status bar goes dark if set too fast on ios
if (Platform.OS === 'ios')
setTimeout(this.setupStatusBar, 1000);
else
this.setupStatusBar();
this.setState({
isLoading: false,
currentTheme: ThemeManager.getCurrentTheme(),
showIntro: AsyncStorageManager.getBool(AsyncStorageManager.PREFERENCES.showIntro.key),
showUpdate: AsyncStorageManager.getNumber(AsyncStorageManager.PREFERENCES.updateNumber.key)
!== Update.number,
showAprilFools: AprilFoolsManager.getInstance().isAprilFoolsEnabled()
&& AsyncStorageManager.getBool(AsyncStorageManager.PREFERENCES.showAprilFoolsStart.key),
});
SplashScreen.hide();
}
/**
* Renders the app based on loading state
*/
render() {
if (this.state.isLoading) {
return null;
} else if (this.state.showIntro || this.state.showUpdate || this.state.showAprilFools) {
return <CustomIntroSlider
onDone={this.onIntroDone}
isUpdate={this.state.showUpdate && !this.state.showIntro}
isAprilFools={this.state.showAprilFools && !this.state.showIntro}
/>;
} else {
return (
<PaperProvider theme={this.state.currentTheme}>
<OverflowMenuProvider>
<View style={{backgroundColor: ThemeManager.getCurrentTheme().colors.background, flex: 1}}>
<SafeAreaView style={{flex: 1}}>
<NavigationContainer theme={this.state.currentTheme} ref={this.navigatorRef}>
<MainNavigator
defaultHomeRoute={this.defaultHomeRoute}
defaultHomeData={this.defaultHomeData}
/>
</NavigationContainer>
</SafeAreaView>
</View>
</OverflowMenuProvider>
</PaperProvider>
);
}
} }
return (
<PaperProvider theme={state.currentTheme}>
<OverflowMenuProvider>
<View
style={{
backgroundColor: ThemeManager.getCurrentTheme().colors.background,
flex: 1,
}}>
<SafeAreaView style={{flex: 1}}>
<NavigationContainer
theme={state.currentTheme}
ref={this.navigatorRef}>
<MainNavigator
defaultHomeRoute={this.defaultHomeRoute}
defaultHomeData={this.defaultHomeData}
/>
</NavigationContainer>
</SafeAreaView>
</View>
</OverflowMenuProvider>
</PaperProvider>
);
}
} }

38
src/managers/DashboardManager.js
View file

@ -1,27 +1,21 @@
// @flow // @flow
import type {ServiceItem} from "./ServicesManager"; import type {ServiceItem} from './ServicesManager';
import ServicesManager from "./ServicesManager"; import ServicesManager from './ServicesManager';
import {StackNavigationProp} from "@react-navigation/stack"; import {getSublistWithIds} from '../utils/Utils';
import {getSublistWithIds} from "../utils/Utils"; import AsyncStorageManager from './AsyncStorageManager';
import AsyncStorageManager from "./AsyncStorageManager";
export default class DashboardManager extends ServicesManager { export default class DashboardManager extends ServicesManager {
getCurrentDashboard(): Array<ServiceItem | null> {
constructor(nav: StackNavigationProp) { const dashboardIdList = AsyncStorageManager.getObject(
super(nav) AsyncStorageManager.PREFERENCES.dashboardItems.key,
} );
const allDatasets = [
getCurrentDashboard(): Array<ServiceItem> { ...this.amicaleDataset,
const dashboardIdList = AsyncStorageManager ...this.studentsDataset,
.getObject(AsyncStorageManager.PREFERENCES.dashboardItems.key); ...this.insaDataset,
const allDatasets = [ ...this.specialDataset,
...this.amicaleDataset, ];
...this.studentsDataset, return getSublistWithIds(dashboardIdList, allDatasets);
...this.insaDataset, }
...this.specialDataset,
];
return getSublistWithIds(dashboardIdList, allDatasets);
}
} }

329
src/utils/URLHandler.js
View file

@ -2,174 +2,199 @@
import {Linking} from 'react-native'; import {Linking} from 'react-native';
export type ParsedUrlDataType = {
route: string,
data: {[key: string]: string},
};
export type ParsedUrlCallbackType = (parsedData: ParsedUrlDataType) => void;
type RawParsedUrlDataType = {
path: string,
queryParams: {[key: string]: string},
};
/** /**
* Class use to handle depp links scanned or clicked. * Class use to handle depp links scanned or clicked.
*/ */
export default class URLHandler { export default class URLHandler {
static SCHEME = 'campus-insat://'; // Urls beginning with this string will be opened in the app
static SCHEME = "campus-insat://"; // Urls beginning with this string will be opened in the app static CLUB_INFO_URL_PATH = 'club';
static CLUB_INFO_URL_PATH = "club"; static EVENT_INFO_URL_PATH = 'event';
static EVENT_INFO_URL_PATH = "event";
static CLUB_INFO_ROUTE = "club-information"; static CLUB_INFO_ROUTE = 'club-information';
static EVENT_INFO_ROUTE = "planning-information";
onInitialURLParsed: Function; static EVENT_INFO_ROUTE = 'planning-information';
onDetectURL: Function;
constructor(onInitialURLParsed: Function, onDetectURL: Function) { onInitialURLParsed: ParsedUrlCallbackType;
this.onInitialURLParsed = onInitialURLParsed;
this.onDetectURL = onDetectURL; onDetectURL: ParsedUrlCallbackType;
constructor(
onInitialURLParsed: ParsedUrlCallbackType,
onDetectURL: ParsedUrlCallbackType,
) {
this.onInitialURLParsed = onInitialURLParsed;
this.onDetectURL = onDetectURL;
}
/**
* Parses the given url to retrieve the corresponding app path and associated arguments.
*
* @param url The url to parse
* @returns {{path: string, queryParams: {}}}
*/
static parseUrl(url: string): RawParsedUrlDataType | null {
let parsedData: RawParsedUrlDataType | null = null;
const urlNoScheme = url.replace(URLHandler.SCHEME, '');
if (urlNoScheme != null) {
const params = {};
const [path, fullParamsString] = urlNoScheme.split('?');
if (fullParamsString != null) {
const paramsStringArray = fullParamsString.split('&');
paramsStringArray.forEach((paramString: string) => {
const [key, value] = paramString.split('=');
if (value != null) {
params[key] = value;
}
});
}
if (path != null) parsedData = {path, queryParams: params};
}
return parsedData;
}
/**
* Gets routing data corresponding to the given url.
* If the url does not match any existing route, null will be returned.
*
* @param rawParsedUrlData The data just parsed
* @returns {null}
*/
static getUrlData(
rawParsedUrlData: RawParsedUrlDataType | null,
): ParsedUrlDataType | null {
let parsedData: null | ParsedUrlDataType = null;
if (rawParsedUrlData != null) {
const {path} = rawParsedUrlData;
const {queryParams} = rawParsedUrlData;
if (URLHandler.isClubInformationLink(path))
parsedData = URLHandler.generateClubInformationData(queryParams);
else if (URLHandler.isPlanningInformationLink(path))
parsedData = URLHandler.generatePlanningInformationData(queryParams);
} }
/** return parsedData;
* Parses the given url to retrieve the corresponding app path and associated arguments. }
*
* @param url The url to parse /**
* @returns {{path: string, queryParams: {}}} * Checks if the given url is in a valid format
*/ *
static parseUrl(url: string) { * @param url The url to check
let params = {}; * @returns {boolean}
let path = ""; */
let temp = url.replace(URLHandler.SCHEME, ""); static isUrlValid(url: string): boolean {
if (temp != null) { return this.getUrlData(URLHandler.parseUrl(url)) !== null;
let array = temp.split("?"); }
if (array != null && array.length > 0) {
path = array[0]; /**
} * Check if the given path links to the club information screen
if (array != null && array.length > 1) { *
let tempParams = array[1].split("&"); * @param path The url to check
for (let i = 0; i < tempParams.length; i++) { * @returns {boolean}
let paramsArray = tempParams[i].split("="); */
if (paramsArray.length > 1) { static isClubInformationLink(path: string): boolean {
params[paramsArray[0]] = paramsArray[1]; return path === URLHandler.CLUB_INFO_URL_PATH;
} }
}
} /**
} * Check if the given path links to the planning information screen
return {path: path, queryParams: params}; *
* @param path The url to check
* @returns {boolean}
*/
static isPlanningInformationLink(path: string): boolean {
return path === URLHandler.EVENT_INFO_URL_PATH;
}
/**
* Generates data formatted for the club information screen from the url parameters.
*
* @param params Url parameters to convert
* @returns {null|{route: string, data: {clubId: number}}}
*/
static generateClubInformationData(params: {
[key: string]: string,
}): ParsedUrlDataType | null {
if (params.id != null) {
const id = parseInt(params.id, 10);
if (!Number.isNaN(id))
return {
route: URLHandler.CLUB_INFO_ROUTE,
data: {clubId: id.toString()},
};
} }
return null;
}
/** /**
* Gets routing data corresponding to the given url. * Generates data formatted for the planning information screen from the url parameters.
* If the url does not match any existing route, null will be returned. *
* * @param params Url parameters to convert
* @param path Url path * @returns {null|{route: string, data: {clubId: number}}}
* @param queryParams Url parameters */
* @returns {null} static generatePlanningInformationData(params: {
*/ [key: string]: string,
static getUrlData({path, queryParams}: { path: string, queryParams: { [key: string]: string } }) { }): ParsedUrlDataType | null {
let data = null; if (params.id != null) {
if (path !== null) { const id = parseInt(params.id, 10);
if (URLHandler.isClubInformationLink(path)) if (!Number.isNaN(id)) {
data = URLHandler.generateClubInformationData(queryParams); return {
else if (URLHandler.isPlanningInformationLink(path)) route: URLHandler.EVENT_INFO_ROUTE,
data = URLHandler.generatePlanningInformationData(queryParams); data: {eventId: id.toString()},
} };
return data; }
} }
return null;
}
/** /**
* Checks if the given url is in a valid format * Starts listening to events.
* *
* @param url The url to check * There are 2 types of event.
* @returns {boolean} *
*/ * A classic event, triggered while the app is active.
static isUrlValid(url: string) { * An initial event, called when the app was opened by clicking on a link
return this.getUrlData(URLHandler.parseUrl(url)) !== null; *
*/
listen() {
Linking.addEventListener('url', this.onUrl);
Linking.getInitialURL().then(this.onInitialUrl);
}
/**
* Gets data from the given url and calls the classic callback with it.
*
* @param url The url detected
*/
onUrl = ({url}: {url: string}) => {
if (url != null) {
const data = URLHandler.getUrlData(URLHandler.parseUrl(url));
if (data != null) this.onDetectURL(data);
} }
};
/** /**
* Check if the given path links to the club information screen * Gets data from the given url and calls the initial callback with it.
* *
* @param path The url to check * @param url The url detected
* @returns {boolean} */
*/ onInitialUrl = (url: ?string) => {
static isClubInformationLink(path: string) { if (url != null) {
return path === URLHandler.CLUB_INFO_URL_PATH; const data = URLHandler.getUrlData(URLHandler.parseUrl(url));
if (data != null) this.onInitialURLParsed(data);
} }
};
/**
* Check if the given path links to the planning information screen
*
* @param path The url to check
* @returns {boolean}
*/
static isPlanningInformationLink(path: string) {
return path === URLHandler.EVENT_INFO_URL_PATH;
}
/**
* Generates data formatted for the club information screen from the url parameters.
*
* @param params Url parameters to convert
* @returns {null|{route: string, data: {clubId: number}}}
*/
static generateClubInformationData(params: Object): Object | null {
if (params !== undefined && params.id !== undefined) {
let id = parseInt(params.id);
if (!isNaN(id)) {
return {route: URLHandler.CLUB_INFO_ROUTE, data: {clubId: id}};
}
}
return null;
}
/**
* Generates data formatted for the planning information screen from the url parameters.
*
* @param params Url parameters to convert
* @returns {null|{route: string, data: {clubId: number}}}
*/
static generatePlanningInformationData(params: Object): Object | null {
if (params !== undefined && params.id !== undefined) {
let id = parseInt(params.id);
if (!isNaN(id)) {
return {route: URLHandler.EVENT_INFO_ROUTE, data: {eventId: id}};
}
}
return null;
}
/**
* Starts listening to events.
*
* There are 2 types of event.
*
* A classic event, triggered while the app is active.
* An initial event, called when the app was opened by clicking on a link
*
*/
listen() {
Linking.addEventListener('url', this.onUrl);
Linking.getInitialURL().then(this.onInitialUrl);
}
/**
* Gets data from the given url and calls the classic callback with it.
*
* @param url The url detected
*/
onUrl = ({url}: { url: string }) => {
if (url != null) {
let data = URLHandler.getUrlData(URLHandler.parseUrl(url));
if (data !== null)
this.onDetectURL(data);
}
};
/**
* Gets data from the given url and calls the initial callback with it.
*
* @param url The url detected
*/
onInitialUrl = (url: ?string) => {
if (url != null) {
let data = URLHandler.getUrlData(URLHandler.parseUrl(url));
if (data !== null)
this.onInitialURLParsed(data);
}
};
} }

60
src/utils/Utils.js
View file

@ -1,5 +1,7 @@
// @flow // @flow
import {Platform, StatusBar} from 'react-native';
import ThemeManager from '../managers/ThemeManager';
/** /**
* Gets a sublist of the given list with items of the given ids only * Gets a sublist of the given list with items of the given ids only
@ -10,28 +12,40 @@
* @param originalList The original list * @param originalList The original list
* @returns {[]} * @returns {[]}
*/ */
export function getSublistWithIds( export function getSublistWithIds<T>(
idList: Array<string>, idList: Array<string>,
originalList: Array<{ key: string, [key: string]: any }> originalList: Array<{key: string, ...T}>,
): Array<{ key: string, [key: string]: any }> { ): Array<{key: string, ...T} | null> {
let subList = []; const subList = [];
for (let i = 0; i < subList.length; i++) { for (let i = 0; i < idList.length; i += 1) {
subList.push(null); subList.push(null);
}
let itemsAdded = 0;
for (let i = 0; i < originalList.length; i += 1) {
const item = originalList[i];
if (idList.includes(item.key)) {
subList[idList.indexOf(item.key)] = item;
itemsAdded += 1;
if (itemsAdded === idList.length) break;
} }
let itemsAdded = 0; }
for (let i = 0; i < originalList.length; i++) { return subList;
const item = originalList[i]; }
if (idList.includes(item.key)) {
subList[idList.indexOf(item.key)] = item; /**
itemsAdded++; * Updates status bar content color if on iOS only,
if (itemsAdded === idList.length) * as the android status bar is always set to black.
break; */
} export function setupStatusBar() {
} if (ThemeManager.getNightMode()) {
for (let i = 0; i < subList.length; i++) { StatusBar.setBarStyle('light-content', true);
if (subList[i] == null) } else {
subList.splice(i, 1); StatusBar.setBarStyle('dark-content', true);
} }
if (Platform.OS === 'android') {
return subList; StatusBar.setBackgroundColor(
ThemeManager.getCurrentTheme().colors.surface,
true,
);
}
} }