Run new prettier config over the codebase

.github/CODE_OF_CONDUCT.md

 Examples of behavior that contributes to creating a positive environment
 include:
 
-* Using welcoming and inclusive language
-* Being respectful of differing viewpoints and experiences
-* Gracefully accepting constructive criticism
-* Focusing on what is best for the community
-* Showing empathy towards other community members
+- Using welcoming and inclusive language
+- Being respectful of differing viewpoints and experiences
+- Gracefully accepting constructive criticism
+- Focusing on what is best for the community
+- Showing empathy towards other community members
 
 Examples of unacceptable behavior by participants include:
 
-* The use of sexualized language or imagery and unwelcome sexual attention or
+- The use of sexualized language or imagery and unwelcome sexual attention or
   advances
-* Trolling, insulting/derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or electronic
+- Trolling, insulting/derogatory comments, and personal or political attacks
+- Public or private harassment
+- Publishing others' private information, such as a physical or electronic
   address, without explicit permission
-* Other conduct which could reasonably be considered inappropriate in a
+- Other conduct which could reasonably be considered inappropriate in a
   professional setting
 
 ## Our Responsibilities

.github/ISSUE_TEMPLATE.md

 
 ### Describe your environment
 
-* React-Native version
-* Platform: iOS, Android, both?
-* Device (which one?), simulator?
-* OS version
-* react-native-permissions version
-* Devtools: Xcode? Android Studio version?
-* (Android only: buildToolsVersion)
+- react-native-permissions version
+- react-native version
+- Target platform: iOS, Android, both?
+- Device (which one?), simulator?
+- OS version
+- DevTools: Xcode version, Android Studio version
+- (Android only: buildToolsVersion)
 
 ### How to repeat issue and example
 

README.md

 
 ## ⚠️ Breaking changes in version 1.0.0
 
-* Now using React Native's own JS `PermissionsAndroid` module on Android, which
+- Now using React Native's own JS `PermissionsAndroid` module on Android, which
   is great because we no longer have to do any additional linking on Android
-* Updated API to be closer to React Native's `PermissionsAndroid`
-* Removed `openSettings()` support on Android (to stay linking-free). There are
+- Updated API to be closer to React Native's `PermissionsAndroid`
+- Removed `openSettings()` support on Android (to stay linking-free). There are
   several NPM modules available for this
-* `restricted` status now supported on Android, although it means something
+- `restricted` status now supported on Android, although it means something
   different than iOS
 
 ## Setup
    folder ➜ `Add Files to <...>`
 2. Go to `node_modules` ➜ `react-native-permissions` ➜ select
    `ReactNativePermissions.xcodeproj`
-3. Add `libReactNativePermissions.a` to `Build Phases` -> `Link Binary With
-   Libraries`
+3. Add `libReactNativePermissions.a` to `Build Phases` -> `Link Binary With Libraries`
 
 ## Using
 
 ```js
-import Permissions from 'react-native-permissions'
+import Permissions from "react-native-permissions";
 // OR const Permissions = require('react-native-permissions').default
 // if you use CommonJS module system
 
 
   // Check the status of a single permission
   componentDidMount() {
-    Permissions.check('photo').then(response => {
+    Permissions.check("photo").then(response => {
       // Response is one of: 'authorized', 'denied', 'restricted', or 'undetermined'
-      this.setState({ photoPermission: response })
-    })
+      this.setState({ photoPermission: response });
+    });
   }
 
   // Request permission to access photos
   _requestPermission = () => {
-    Permissions.request('photo').then(response => {
+    Permissions.request("photo").then(response => {
       // Returns once the user has chosen to 'allow' or to 'not allow' access
       // Response is one of: 'authorized', 'denied', 'restricted', or 'undetermined'
-      this.setState({ photoPermission: response })
-    })
-  }
+      this.setState({ photoPermission: response });
+    });
+  };
 
   // Check the status of multiple permissions
   _checkCameraAndPhotos = () => {
-    Permissions.checkMultiple(['camera', 'photo']).then(response => {
+    Permissions.checkMultiple(["camera", "photo"]).then(response => {
       //response is an object mapping type to permission
       this.setState({
         cameraPermission: response.camera,
         photoPermission: response.photo,
-      })
-    })
-  }
+      });
+    });
+  };
 
   // This is a common pattern when asking for permissions.
   // iOS only gives you once chance to show the permission dialog,
   // If the user already denied access, we can ask them to enable it from settings.
   _alertForPhotosPermission() {
     Alert.alert(
-      'Can we access your photos?',
-      'We need access so you can set your profile pic',
+      "Can we access your photos?",
+      "We need access so you can set your profile pic",
       [
         {
-          text: 'No way',
-          onPress: () => console.log('Permission denied'),
-          style: 'cancel',
+          text: "No way",
+          onPress: () => console.log("Permission denied"),
+          style: "cancel",
         },
-        this.state.photoPermission == 'undetermined'
-          ? { text: 'OK', onPress: this._requestPermission }
-          : { text: 'Open Settings', onPress: Permissions.openSettings },
+        this.state.photoPermission == "undetermined"
+          ? { text: "OK", onPress: this._requestPermission }
+          : { text: "Open Settings", onPress: Permissions.openSettings },
       ],
-    )
+    );
   }
 
   //...
 | Return value   | Notes                                                                                                                                                                                                                                                                  |
 | -------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `authorized`   | User has authorized this permission                                                                                                                                                                                                                                    |
-| `denied`       | User has denied this permission at least once. On iOS this means that the user will not be prompted again. Android users can be prompted multiple times until they select 'Never ask me again'                                                                          |
+| `denied`       | User has denied this permission at least once. On iOS this means that the user will not be prompted again. Android users can be prompted multiple times until they select 'Never ask me again'                                                                         |
 | `restricted`   | **iOS** - this means user is not able to grant this permission, either because it's not supported by the device or because it has been blocked by parental controls. **Android** - this means that the user has selected 'Never ask me again' while denying permission |
 | `undetermined` | User has not yet been prompted with a permission dialog                                                                                                                                                                                                                |
 
 
 ### iOS Notes
 
-* Permission type `bluetooth` represents the status of the
+- Permission type `bluetooth` represents the status of the
   `CBPeripheralManager`. Don't use this if only need `CBCentralManager`
-* Permission type `location` accepts a second parameter for `request()` and
+- Permission type `location` accepts a second parameter for `request()` and
   `check()`; the second parameter is a string, either `always` or `whenInUse`
   (default).
-* Permission type `notification` accepts a second parameter for `request()`. The
+- Permission type `notification` accepts a second parameter for `request()`. The
   second parameter is an array with the desired alert types. Any combination of
   `alert`, `badge` and `sound` (default requests all three).
-* If you are not requesting mediaLibrary then you can remove MediaPlayer.framework from the xcode project
+- If you are not requesting mediaLibrary then you can remove MediaPlayer.framework from the xcode project
 
 ```js
 // example
-Permissions.check('location', { type: 'always' }).then(response => {
-  this.setState({ locationPermission: response })
-})
+Permissions.check("location", { type: "always" }).then(response => {
+  this.setState({ locationPermission: response });
+});
 
-Permissions.request('location', { type: 'always' }).then(response => {
-  this.setState({ locationPermission: response })
-})
+Permissions.request("location", { type: "always" }).then(response => {
+  this.setState({ locationPermission: response });
+});
 
-Permissions.request('notification', { type: ['alert', 'badge'] }).then(
+Permissions.request("notification", { type: ["alert", "badge"] }).then(
   response => {
-    this.setState({ notificationPermission: response })
+    this.setState({ notificationPermission: response });
   },
-)
+);
 ```
 
-* You cannot request microphone permissions on the simulator.
-* With Xcode 8, you now need to add usage descriptions for each permission you
+- You cannot request microphone permissions on the simulator.
+- With Xcode 8, you now need to add usage descriptions for each permission you
   will request. Open Xcode ➜ `Info.plist` ➜ Add a key (starting with "Privacy -
   ...") with your kit specific permission.
 
-Example: If you need Contacts permission you have to add the key `Privacy -
-Contacts Usage Description`.
+Example: If you need Contacts permission you have to add the key `Privacy - Contacts Usage Description`.
 
 <img width="338" alt="3cde3b44-7ffd-11e6-918b-63888e33f983" src="https://cloud.githubusercontent.com/assets/1440796/18713019/271be540-8011-11e6-87fb-c3828c172dfc.png">
 
 <key>NSMotionUsageDescription</key>
 <string>Some description</string>
 ```
+
 This is required because during the phase of processing in the App Store
 submission, the system detects that you app contains code to request the
 permission `X` but don't have the `UsageDescription` key and then it rejects the
 
 ### Android Notes
 
-* Uses React Native's own
+- Uses React Native's own
   [`PermissionsAndroid` JS API](http://facebook.github.io/react-native/docs/permissionsandroid.html).
-* All required permissions also need to be included in the `AndroidManifest.xml`
+- All required permissions also need to be included in the `AndroidManifest.xml`
   file before they can be requested. Otherwise `request()` will immediately
   return `denied`.
-* You can request write access to any of these types by also including the
+- You can request write access to any of these types by also including the
   appropriate write permission in the `AndroidManifest.xml` file. Read more
   [here](https://developer.android.com/guide/topics/security/permissions.html#normal-dangerous).
 
-* The optional rationale argument will show a dialog prompt.
+- The optional rationale argument will show a dialog prompt.
 
 ```js
 // example
-Permissions.request('camera', {
+Permissions.request("camera", {
   rationale: {
-    title: 'Cool Photo App Camera Permission',
+    title: "Cool Photo App Camera Permission",
     message:
-      'Cool Photo App needs access to your camera ' +
-      'so you can take awesome pictures.',
+      "Cool Photo App needs access to your camera " +
+      "so you can take awesome pictures.",
   },
 }).then(response => {
-  this.setState({ cameraPermission: response })
-})
+  this.setState({ cameraPermission: response });
+});
 ```
 
-* Permissions are automatically accepted for **targetSdkVersion < 23** but you
+- Permissions are automatically accepted for **targetSdkVersion < 23** but you
   can still use `check()` to check if the user has disabled them from Settings.
 
 You might need to elevate the **targetSdkVersion** version in your

index.js

 // @flow
 
-import Permissions from './lib/permissions'
-export default Permissions
+import Permissions from "./lib/permissions";
+export default Permissions;

lib/permissions.android.js

 // @flow
 
-import { AsyncStorage, NativeModules, PermissionsAndroid } from 'react-native'
+import { AsyncStorage, NativeModules, PermissionsAndroid } from "react-native";
 
-type Status = 'authorized' | 'denied' | 'restricted' | 'undetermined'
-type Rationale = { title: string, message: string }
-type CheckOptions = string | { type: string }
-type RequestOptions = string | { type: string, rationale?: Rationale }
+type Status = "authorized" | "denied" | "restricted" | "undetermined";
+type Rationale = { title: string, message: string };
+type CheckOptions = string | { type: string };
+type RequestOptions = string | { type: string, rationale?: Rationale };
 
 const permissionTypes = {
   location: PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION,
   callPhone: PermissionsAndroid.PERMISSIONS.CALL_PHONE,
   readSms: PermissionsAndroid.PERMISSIONS.READ_SMS,
   receiveSms: PermissionsAndroid.PERMISSIONS.RECEIVE_SMS,
-}
+};
 
 const RESULTS = {
-  [PermissionsAndroid.RESULTS.GRANTED]: 'authorized',
-  [PermissionsAndroid.RESULTS.DENIED]: 'denied',
-  [PermissionsAndroid.RESULTS.NEVER_ASK_AGAIN]: 'restricted',
-}
+  [PermissionsAndroid.RESULTS.GRANTED]: "authorized",
+  [PermissionsAndroid.RESULTS.DENIED]: "denied",
+  [PermissionsAndroid.RESULTS.NEVER_ASK_AGAIN]: "restricted",
+};
 
-const STORAGE_KEY = '@RNPermissions:didAskPermission:'
+const STORAGE_KEY = "@RNPermissions:didAskPermission:";
 
 const setDidAskOnce = (permission: string) =>
-  AsyncStorage.setItem(STORAGE_KEY + permission, 'true')
+  AsyncStorage.setItem(STORAGE_KEY + permission, "true");
 
 const getDidAskOnce = (permission: string) =>
-  AsyncStorage.getItem(STORAGE_KEY + permission).then(item => !!item)
+  AsyncStorage.getItem(STORAGE_KEY + permission).then(item => !!item);
 
 class ReactNativePermissions {
-  canOpenSettings: () => Promise<boolean> = () => Promise.resolve(false)
+  canOpenSettings: () => Promise<boolean> = () => Promise.resolve(false);
 
   openSettings: () => Promise<*> = () =>
-    Promise.reject(new Error("'openSettings' is deprecated on android"))
+    Promise.reject(new Error("'openSettings' is deprecated on android"));
 
-  getTypes: () => Array<string> = () => Object.keys(permissionTypes)
+  getTypes: () => Array<string> = () => Object.keys(permissionTypes);
 
   check = (permission: string, options?: CheckOptions): Promise<Status> => {
     if (!permissionTypes[permission]) {
       const error = new Error(
-        `ReactNativePermissions: ${
-          permission
-        } is not a valid permission type on Android`,
-      )
+        `ReactNativePermissions: ${permission} is not a valid permission type on Android`,
+      );
 
-      return Promise.reject(error)
+      return Promise.reject(error);
     }
 
     return PermissionsAndroid.check(permissionTypes[permission]).then(
       isAuthorized => {
         if (isAuthorized) {
-          return 'authorized'
+          return "authorized";
         }
 
         return getDidAskOnce(permission).then(didAsk => {
           if (didAsk) {
             return NativeModules.PermissionsAndroid.shouldShowRequestPermissionRationale(
               permissionTypes[permission],
-            ).then(shouldShow => (shouldShow ? 'denied' : 'restricted'))
+            ).then(shouldShow => (shouldShow ? "denied" : "restricted"));
           }
 
-          return 'undetermined'
-        })
+          return "undetermined";
+        });
       },
-    )
-  }
+    );
+  };
 
   request = (permission: string, options?: RequestOptions): Promise<Status> => {
     if (!permissionTypes[permission]) {
       const error = new Error(
-        `ReactNativePermissions: ${
-          permission
-        } is not a valid permission type on Android`,
-      )
+        `ReactNativePermissions: ${permission} is not a valid permission type on Android`,
+      );
 
-      return Promise.reject(error)
+      return Promise.reject(error);
     }
 
-    let rationale
+    let rationale;
 
     if (options && options.rationale) {
-      rationale = options.rationale
+      rationale = options.rationale;
     }
 
     return PermissionsAndroid.request(
     ).then(result => {
       // PermissionsAndroid.request() to native module resolves to boolean
       // rather than string if running on OS version prior to Android M
-      if (typeof result === 'boolean') {
-        return result ? 'authorized' : 'denied'
+      if (typeof result === "boolean") {
+        return result ? "authorized" : "denied";
       }
 
-      return setDidAskOnce(permission).then(() => RESULTS[result])
-    })
-  }
+      return setDidAskOnce(permission).then(() => RESULTS[result]);
+    });
+  };
 
   checkMultiple = (permissions: Array<string>): Promise<{ [string]: string }> =>
     Promise.all(permissions.map(permission => this.check(permission))).then(
       result =>
         result.reduce((acc, value, index) => {
-          const name = permissions[index]
-          acc[name] = value
-          return acc
+          const name = permissions[index];
+          acc[name] = value;
+          return acc;
         }, {}),
-    )
+    );
 }
 
-export default new ReactNativePermissions()
+export default new ReactNativePermissions();

lib/permissions.ios.js

 // @flow
 
-import { NativeModules } from 'react-native'
-const PermissionsIOS = NativeModules.ReactNativePermissions
+import { NativeModules } from "react-native";
+const PermissionsIOS = NativeModules.ReactNativePermissions;
 
-type Status = 'authorized' | 'denied' | 'restricted' | 'undetermined'
-type Rationale = { title: string, message: string }
-type CheckOptions = string | { type: string }
-type RequestOptions = string | { type: string, rationale?: Rationale }
+type Status = "authorized" | "denied" | "restricted" | "undetermined";
+type Rationale = { title: string, message: string };
+type CheckOptions = string | { type: string };
+type RequestOptions = string | { type: string, rationale?: Rationale };
 
 const permissionTypes = [
-  'location',
-  'camera',
-  'microphone',
-  'photo',
-  'contacts',
-  'event',
-  'reminder',
-  'bluetooth',
-  'notification',
-  'backgroundRefresh',
-  'speechRecognition',
-  'mediaLibrary',
-  'motion'
-]
+  "location",
+  "camera",
+  "microphone",
+  "photo",
+  "contacts",
+  "event",
+  "reminder",
+  "bluetooth",
+  "notification",
+  "backgroundRefresh",
+  "speechRecognition",
+  "mediaLibrary",
+  "motion",
+];
 
 const DEFAULTS = {
-  location: 'whenInUse',
-  notification: ['alert', 'badge', 'sound'],
-}
+  location: "whenInUse",
+  notification: ["alert", "badge", "sound"],
+};
 
 class ReactNativePermissions {
   canOpenSettings: () => Promise<boolean> = () =>
-    PermissionsIOS.canOpenSettings()
+    PermissionsIOS.canOpenSettings();
 
-  openSettings: () => Promise<*> = () => PermissionsIOS.openSettings()
+  openSettings: () => Promise<*> = () => PermissionsIOS.openSettings();
 
-  getTypes: () => Array<string> = () => permissionTypes
+  getTypes: () => Array<string> = () => permissionTypes;
 
   check = (permission: string, options?: CheckOptions): Promise<Status> => {
     if (!permissionTypes.includes(permission)) {
       const error = new Error(
-        `ReactNativePermissions: ${
-          permission
-        } is not a valid permission type on iOS`,
-      )
+        `ReactNativePermissions: ${permission} is not a valid permission type on iOS`,
+      );
 
-      return Promise.reject(error)
+      return Promise.reject(error);
     }
 
-    let type
+    let type;
 
-    if (typeof options === 'string') {
-      type = options
+    if (typeof options === "string") {
+      type = options;
     } else if (options && options.type) {
-      type = options.type
+      type = options.type;
     }
 
     return PermissionsIOS.getPermissionStatus(
       permission,
       type || DEFAULTS[permission],
-    )
-  }
+    );
+  };
 
   request = (permission: string, options?: RequestOptions): Promise<Status> => {
     if (!permissionTypes.includes(permission)) {
       const error = new Error(
-        `ReactNativePermissions: ${
-          permission
-        } is not a valid permission type on iOS`,
-      )
+        `ReactNativePermissions: ${permission} is not a valid permission type on iOS`,
+      );
 
-      return Promise.reject(error)
+      return Promise.reject(error);
     }
 
-    if (permission == 'backgroundRefresh') {
+    if (permission == "backgroundRefresh") {
       const error = new Error(
-        'ReactNativePermissions: You cannot request backgroundRefresh',
-      )
+        "ReactNativePermissions: You cannot request backgroundRefresh",
+      );
 
-      return Promise.reject(error)
+      return Promise.reject(error);
     }
 
-    let type
+    let type;
 
-    if (typeof options === 'string') {
-      type = options
+    if (typeof options === "string") {
+      type = options;
     } else if (options && options.type) {
-      type = options.type
+      type = options.type;
     }
 
     return PermissionsIOS.requestPermission(
       permission,
       type || DEFAULTS[permission],
-    )
-  }
+    );
+  };
 
   checkMultiple = (permissions: Array<string>): Promise<{ [string]: string }> =>
     Promise.all(permissions.map(permission => this.check(permission))).then(
       result =>
         result.reduce((acc, value, index) => {
-          const name = permissions[index]
-          acc[name] = value
-          return acc
+          const name = permissions[index];
+          acc[name] = value;
+          return acc;
         }, {}),
-    )
+    );
 }
 
-export default new ReactNativePermissions()
+export default new ReactNativePermissions();