Merge branch 'master' of https://github.com/ionic-team/ionic-native

Adds the missing Android-only `saveHistory` option.

https://github.com/phonegap/phonegap-plugin-barcodescanner#using-the-plugin
https://github.com/phonegap/phonegap-plugin-barcodescanner/blob/v8.1.0/src/android/com/phonegap/plugins/barcodescanner/BarcodeScanner.java#L52

.editorconfig

@@ -1,15 +1,15 @@
-# http://editorconfig.org
-
-root = true
-
-[*]
-charset = utf-8
-indent_style = space
-indent_size = 2
-end_of_line = lf
-insert_final_newline = true
-trim_trailing_whitespace = true
-
-[*.md]
-insert_final_newline = false
+# http://editorconfig.org
+
+root = true
+
+[*]
+charset = utf-8
+indent_style = space
+indent_size = 2
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[*.md]
+insert_final_newline = false
 trim_trailing_whitespace = false

.github/CONTRIBUTING.md

@@ -4,7 +4,7 @@
 #### There are no rules, but here are a few things to consider:
 ###### Before you submit an issue:
 * Do a quick search to see if there are similar issues
-* Make sure that you are waiting for `deviceready` to fire before interacting with any plugin. If you are using Ionic 2, this can be done using [the `Platform.ready()` function](http://ionicframework.com/docs/api/platform/Platform/#ready).
+* Make sure that you are waiting for `deviceready` to fire before interacting with any plugin. If you are using Ionic, this can be done using [the `Platform.ready()` function](http://ionicframework.com/docs/api/platform/Platform/#ready).
 * **Check that you are using the latest version of** `ionic-native`, you can install the latest version by running `npm i --save @ionic-native/core@latest`
 
 ###### Still having problems? submit an issue with the following details:
@@ -16,4 +16,4 @@
 ## Feature request?
 Have a plugin you'd like to see supported? Since Ionic Native is a thin wrapper around existing Cordova plugins, adding support for new plugins is as easy as creating a new wrapper for whatever plugin you'd like to add.
 
-Take a look at our [Developer Guide](https://github.com/driftyco/ionic-native/blob/master/DEVELOPER.md) for more info on adding new plugins.
+Take a look at our [Developer Guide](https://github.com/ionic-team/ionic-native/blob/master/DEVELOPER.md) for more info on adding new plugins.

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,28 @@
+**I'm submitting a ...**  (check one with "x")
+[ ] bug report
+[ ] feature request
+[ ] support request => Please do not submit support requests here, use one of these channels: https://forum.ionicframework.com/ or https://ionicworldwide.herokuapp.com/
+
+**Current behavior:**
+<!-- Describe how the bug manifests. -->
+
+**Expected behavior:**
+<!-- Describe what the behavior would be without the bug. -->
+
+**Steps to reproduce:**
+<!-- If you are able to illustrate the bug or feature request with an example, please provide steps to reproduce. -->
+
+**Related code:**
+
+```
+insert any relevant code here
+```
+
+**Other information:**
+<!-- List any other information that is relevant to your issue. Stack traces, related issues, suggestions on how to fix, Stack Overflow links, forum links, etc. -->
+
+**Ionic info:** (run `ionic info` from a terminal/cmd prompt and paste output below):
+
+```
+insert the output from ionic info here
+```

.github/workflows/codeql-analysis.yml

@@ -0,0 +1,71 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ master ]
+  schedule:
+    - cron: '37 7 * * 2'
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'javascript' ]
+        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python' ]
+        # Learn more:
+        # https://docs.github.com/en/free-pro-team@latest/github/finding-security-vulnerabilities-and-errors-in-your-code/configuring-code-scanning#changing-the-languages-that-are-analyzed
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v2
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v1
+      with:
+        languages: ${{ matrix.language }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+        # queries: ./path/to/local/query, your-org/your-repo/queries@main
+
+    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
+    # If this step fails, then you should remove it and run the build manually (see below)
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v1
+
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 https://git.io/JvXDl
+
+    # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
+    #    and modify them (or add more) to build your code if your project
+    #    uses a compiled language
+
+    #- run: |
+    #   make bootstrap
+    #   make release
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v1

.github/workflows/nodejs.yml

@@ -0,0 +1,46 @@
+name: Node CI
+
+on: [push]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [14.x]
+
+    steps:
+    - uses: actions/checkout@v1
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v1
+      with:
+        node-version: ${{ matrix.node-version }}
+    - name: Cache ionic site
+      id: ionic-site
+      uses: actions/cache@v2
+      with:
+        path: ~/ionic-site/
+        key: ionic-site-${{ hashFiles('**/package-lock.json') }}
+    - name: Setup git
+      run: bash ./scripts/git/config.sh
+    - name: Prepare ionic-site repo
+      if: github.ref == 'refs/heads/master'
+      run: bash ./scripts/docs/prepare.sh
+    - name: Install dependencies
+      run: npm ci
+    - name: Lint
+      run: npm run lint
+    - name: Build
+      run: npm run build
+    - name: Test
+      run: npm run test
+    - name: Readmes
+      run: npm run readmes
+    - name: Deploy doc
+      if: github.ref == 'refs/heads/master'
+      run: bash ./scripts/docs/update_docs.sh
+      env:
+        GITHUB_PROJECT_REPONAME: ${{ github.repository }}
+        GITHUB_SHA1: ${{ github.sha }}

.github/workflows/npmpublish.yml

@@ -0,0 +1,38 @@
+name: Node.js Package
+
+on:
+  release:
+    types: [created]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v1
+      - uses: actions/setup-node@v1
+        with:
+          node-version: 14
+      - name: Install dependencies
+        run: npm ci
+      - name: Lint
+        run: npm run lint
+      - name: Build
+        run: npm run build
+      - name: Test
+        run: npm run test
+      - name: Readmes
+        run: npm run readmes
+
+  publish-npm:
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v1
+      - uses: actions/setup-node@v1
+        with:
+          node-version: 14
+          registry-url: https://registry.npmjs.org/
+      - run: npm ci
+      - run: npm run shipit
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.NPM_TOKEN}}

.github/workflows/stale.yml

@@ -0,0 +1,22 @@
+name: Mark stale issues and pull requests
+
+on:
+  schedule:
+  - cron: '42 5 * * *'
+
+jobs:
+  stale:
+
+    runs-on: ubuntu-latest
+    permissions:
+      issues: write
+      pull-requests: write
+
+    steps:
+    - uses: actions/stale@v3
+      with:
+        repo-token: ${{ secrets.GITHUB_TOKEN }}
+        stale-issue-message: 'Thanks for the issue! This issue is being closed due to inactivity. If this is still an issue, please create a new issue and ensure the template is fully filled out.'
+        stale-pr-message: 'Stale pull request message'
+        stale-issue-label: 'no-issue-activity'
+        stale-pr-label: 'no-pr-activity'

.gitignore

@@ -3,5 +3,10 @@ node_modules/
 .idea
 .tmp
 aot/
-dist/
 scripts/ionic-native-bower
+scripts/docs-json/*.json
+dist/
+src/@ionic-native/plugins/**/ngx
+*.d.ts
+injectable-classes.json
+

.husky/.gitignore

@@ -0,0 +1 @@
+_

.husky/pre-commit

@@ -0,0 +1,4 @@
+#!/bin/sh
+. "$(dirname "$0")/_/husky.sh"
+
+npx --no-install lint-staged

.husky/pre-push

@@ -0,0 +1,4 @@
+#!/bin/sh
+. "$(dirname "$0")/_/husky.sh"
+
+npm test

.prettierignore

@@ -0,0 +1,9 @@
+package.json
+node_modules
+.github
+.vscode
+dist
+CHANGELOG.md
+.husky
+.prettierignore
+LICENSE

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+  "typescript.tsdk": "node_modules/typescript/lib"
+}

CODE_OF_CONDUCT.md

@@ -0,0 +1,11 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of the Ionic project, we pledge to respect everyone who contributes by posting issues, updating documentation, submitting pull requests, providing feedback in comments, and any other activities.
+
+Communication through any of Ionic's channels (GitHub, Slack, Forum, IRC, mailing lists, Twitter, etc.) must be constructive and never resort to personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+We promise to extend courtesy and respect to everyone involved in this project regardless of gender, gender identity, sexual orientation, disability, age, race, ethnicity, religion, or level of experience. We expect anyone contributing to the Ionic project to do the same.
+
+If any member of the community violates this code of conduct, the maintainers of the Ionic project may take action, removing issues, comments, and PRs or blocking accounts as deemed appropriate.
+
+If you are subject to or witness unacceptable behavior, or have any other concerns, please email us at [hi@ionicframework.com](mailto:hi@ionicframework.com).

DEVELOPER.md

@@ -2,15 +2,14 @@
 
 This is a short guide on creating new plugin wrappers for Ionic Native.
 
-
 ## Creating Plugin Wrappers
 
 First, let's start by creating a new plugin wrapper from template.
- 
+
 ```
 // Call this command, and replace PluginName with the name of the plugin you wish to add
 // Make sure to capitalize the first letter, or use CamelCase if necessary.
- 
+
 gulp plugin:create -n PluginName
 
 // add -m flag to get a minimal template to start with
@@ -71,7 +70,7 @@ export class Geolocation {
 
 Here, `plugin` is the name of the plugin package on npm and used when calling `cordova plugin add`.
 
-`pluginRef` refers to the where on `window` the underlying Cordova plugin is normally exposed.  For example, in the case of the Cordova Geolocation plugin, normally you would make calls like `window.navigator.geolocation.getCurrentPosition({}, success, error)`, so the `pluginRef` in this case is `navigator.geolocation`.
+`pluginRef` refers to the where on `window` the underlying Cordova plugin is normally exposed. For example, in the case of the Cordova Geolocation plugin, normally you would make calls like `window.navigator.geolocation.getCurrentPosition({}, success, error)`, so the `pluginRef` in this case is `navigator.geolocation`.
 
 #### Class Methods
 
@@ -86,9 +85,7 @@ Let's take a look at `getCurrentPosition` first.
 
 It's just a stub. The `return` is only there to keep the TypeScript type-checker from complaining since we indicate that `getCurrentPosition` returns a `Promise<Geoposition>`.
 
-By default, the `@Cordova` decorator wraps the plugin callbacks in a Promise that resolves when the success callback is called and rejects when the error callback is called.  It also ensures that Cordova and the underlying plugin are available, and prints helpful diagnostics if they aren't.
-
-You'll also notice that `getCurrentPosition` is a static method. That's because the plugin class is just a utility class to call the underlying Cordova plugin methods, it's not an instance and has no state.
+By default, the `@Cordova` decorator wraps the plugin callbacks in a Promise that resolves when the success callback is called and rejects when the error callback is called. It also ensures that Cordova and the underlying plugin are available, and prints helpful diagnostics if they aren't.
 
 Next, let's look at the `watchPosition` method.
 
@@ -103,9 +100,9 @@ Next, let's look at the `watchPosition` method.
 
 The `@Cordova` decorator has a few more options now.
 
-`observable` indicates that this method may call its callbacks multiple times, so `@Cordova` wraps it in an [`Observable`](https://github.com/driftyco/ionic-native#promises-and-observables) instead of a Promise.
+`observable` indicates that this method may call its callbacks multiple times, so `@Cordova` wraps it in an [`Observable`](https://github.com/ionic-team/ionic-native#promises-and-observables) instead of a Promise.
 
-`callbackOrder` refers to the method signature of the underlying Cordova plugin, and tells Ionic Native which arguments are the callbacks to map to the wrapping Promise or Observable.  In this case, the signature is [`watchPosition(success, error, options)`](https://github.com/apache/cordova-plugin-geolocation#navigatorgeolocationwatchposition), so we need to tell `@Cordova` that the callbacks are the first arguments, not the last arguments.  For rare cases, you can also specify the options `successIndex` and `errorIndex` to indicate where in the argument list the callbacks are located.
+`callbackOrder` refers to the method signature of the underlying Cordova plugin, and tells Ionic Native which arguments are the callbacks to map to the wrapping Promise or Observable. In this case, the signature is [`watchPosition(success, error, options)`](https://github.com/apache/cordova-plugin-geolocation#navigatorgeolocationwatchposition), so we need to tell `@Cordova` that the callbacks are the first arguments, not the last arguments. For rare cases, you can also specify the options `successIndex` and `errorIndex` to indicate where in the argument list the callbacks are located.
 
 `clearFunction` is used in conjunction with the `observable` option and indicates the function to be called when the Observable is disposed.
 
@@ -115,11 +112,11 @@ You need to run `npm run build` in the `ionic-native` project, this will create
 
 ### Cleaning the code
 
-You need to run `npm run lint` to analyze the code and ensure it's consistency with the repository style. Fix any errors before submitting a PR.
+You need to run `npm run lint` to analyze the code and ensure its consistency with the repository style. Fix any errors before submitting a PR.
 
 ### 'Wrapping' Up
 
-That's it! The only thing left to do is rigorously document the plugin and it's usage. Take a look at some of the other plugins for good documentation styles.
+That's it! The only thing left to do is rigorously document the plugin and its usage. Take a look at some of the other plugins for good documentation styles.
 
 ## Commit Message Format
 
@@ -128,43 +125,50 @@ We have very precise rules over how our git commit messages can be formatted. Th
 `type(scope): subject`
 
 #### Type
+
 Must be one of the following:
 
-* **fix**: A bug fix
-* **feat**: A new feature
-* **docs**: Documentation only changes
-* **style**: Changes that do not affect the meaning of the code (white-space, formatting, missing semi-colons, etc)
-* **refactor**: A code change that neither fixes a bug nor adds a feature
-* **perf**: A code change that improves performance
-* **test**: Adding missing tests
-* **chore**: Changes to the build process or auxiliary tools and libraries such as documentation generation
+- **fix**: A bug fix
+- **feat**: A new feature
+- **docs**: Documentation only changes
+- **style**: Changes that do not affect the meaning of the code (white-space, formatting, missing semi-colons, etc)
+- **refactor**: A code change that neither fixes a bug nor adds a feature
+- **perf**: A code change that improves performance
+- **test**: Adding missing tests
+- **chore**: Changes to the build process or auxiliary tools and libraries such as documentation generation
 
 #### Scope
+
 The scope could be anything specifying place of the commit change. For example, the name of the plugin being changed
 
 #### Subject
+
 The subject contains succinct description of the change:
 
-* use the imperative, present tense: "change" not "changed" nor "changes"
-* do not capitalize first letter
-* do not place a period (.) at the end
-* entire length of the commit message must not go over 50 characters
-
+- use the imperative, present tense: "change" not "changed" nor "changes"
+- do not capitalize first letter
+- do not place a period (.) at the end
+- entire length of the commit message must not go over 50 characters
 
 ### Ionic Native Decorators
 
 #### Plugin
+
 A decorator to wrap the main plugin class, and any other classes that will use `@Cordova` or `@CordovaProperty` decorators. This decorator accepts the following configuration:
-- *pluginName*: Plugin name, this should match the class name
-- *plugin*: The plugin's NPM package, or Github URL if NPM is not available.
-- *pluginRef*: The plugin object reference. Example: 'cordova.file'.
-- *repo*: The plugin's Github Repository URL
-- *install*: (optional) Install command. This is used in case a plugin has a custom install command (takes variables).
-- *platforms*: An array of strings indicating the supported platforms. 
+
+- _pluginName_: Plugin name, this should match the class name
+- _plugin_: The plugin's NPM package, or Github URL if NPM is not available.
+- _pluginRef_: The plugin object reference. Example: 'cordova.file'.
+- _repo_: The plugin's Github Repository URL
+- _install_: (optional) Install command. This is used in case a plugin has a custom install command (takes variables).
+- _platforms_: An array of strings indicating the supported platforms.
 
 #### Cordova
+
 Checks if the plugin and the method are available before executing. By default, the decorator will wrap the callbacks of the function and return a Promise. This decorator takes the following configuration options:
+
 - **observable**: set to true to return an Observable
+- **methodName**: an optional name of the cordova plugins method name (if different from wrappers method name)
 - **clearFunction**: an optional name of a method to clear the observable we returned
 - **clearWithArgs**: This can be used if clearFunction is set. Set this to true to call the clearFunction with the same arguments used in the initial function.
 - **sync**: set to true if the method should return the value as-is without wrapping with Observable/Promise
@@ -181,6 +185,7 @@ Checks if the plugin and the method are available before executing. By default,
 - **platforms**: array of strings indicating supported platforms. Specify this if the supported platforms doesn't match the plugin's supported platforms.
 
 Example:
+
 ```ts
 @Cordova()
 someMethod(): Promise<any> { return; }
@@ -190,23 +195,39 @@ syncMethod(): number { }
 ```
 
 #### CordovaProperty
+
 Checks if the plugin and property exist before getting/setting the property's value
 
 Example:
+
 ```ts
-@CordovaProperty
+@CordovaProperty()
 someProperty: string;
 ```
 
 #### CordovaCheck
-Checks if the plugin exists before performing a custom written method. By default, the method will return a promise that will reject with an error if the plugin is not available.  This wrapper accepts two optional configurations:
+
+Checks if the plugin exists before performing a custom written method. By default, the method will return a promise that will reject with an error if the plugin is not available. This wrapper accepts two optional configurations:
+
 - **observable**: set to true to return an empty Observable if the plugin isn't available
 - **sync**: set to true to return nothing if the plugin isn't available
 
 Example:
+
 ```ts
 @CordovaCheck()
 someMethod(): Promise<any> {
   // anything here will only run if the plugin is available
 }
-```
+```
+
+#### CordovaFunctionOverride
+
+Wrap a stub function in a call to a Cordova plugin, checking if both Cordova and the required plugin are installed.
+
+Example:
+
+```ts
+@CordovaFunctionOverride()
+someMethod(): Observable<any> { return; }
+```

LICENSE

@@ -1,23 +1,23 @@
-Copyright 2015-present Drifty Co.
-http://drifty.com/
-
-MIT License
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+Copyright 2015-present Drifty Co.
+http://drifty.com/
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.md

@@ -1,32 +1,43 @@
-[![Circle CI](https://circleci.com/gh/driftyco/ionic-native.svg?style=shield)](https://circleci.com/gh/driftyco/ionic-native) [![Commitizen friendly](https://img.shields.io/badge/commitizen-friendly-brightgreen.svg)](http://commitizen.github.io/cz-cli/) ![](https://img.shields.io/npm/v/@ionic-native/core.svg)
-
+[![Circle CI](https://circleci.com/gh/ionic-team/ionic-native.svg?style=shield)](https://circleci.com/gh/ionic-team/ionic-native) [![Commitizen friendly](https://img.shields.io/badge/commitizen-friendly-brightgreen.svg)](http://commitizen.github.io/cz-cli/) ![](https://img.shields.io/npm/v/@ionic-native/core.svg)
 
 # Ionic Native
 
-Ionic Native is a curated set of wrappers for Cordova plugins that make adding any native functionality you need to your [Ionic 2](http://ionicframework.com/) mobile app easy.
+Ionic Native is a curated set of wrappers for Cordova plugins that make adding any native functionality you need to your [Ionic](https://ionicframework.com/) mobile app easy.
 
 Ionic Native wraps plugin callbacks in a Promise or Observable, providing a common interface for all plugins and making it easy to use plugins with Angular change detection.
 
+Ionic Native is available in two versions: 
+1. Ionic Native [Community Edition](https://ionicframework.com/docs/native/community), featuring open source, community-maintained Cordova and Capacitor plugins and APIs.
+2. Ionic Native [Enterprise Edition](https://ionicframework.com/docs/enterprise), featuring a library of Premier plugins and solutions that are fully supported and maintained by the Ionic team, with access to Ionic experts and a guaranteed response SLA to mission-critical app development.
+
+## Capacitor Support
+
+In addition to Cordova, Ionic Native also works with [Capacitor](https://capacitor.ionicframework.com), Ionic's official native runtime. Basic usage below. For complete details, [see the Capacitor documentation](https://capacitor.ionicframework.com/docs/cordova/using-cordova-plugins).
+
 ## Installation
 
 Run following command to install Ionic Native in your project.
+
 ```bash
 npm install @ionic-native/core --save
 ```
 
-You also need to install the Ionic Native package for each plugin you want to add. Please see the [Ionic Native documentation](http://ionicframework.com/docs/native/) for complete instructions on how to add and use the plugins.
+You also need to install the Ionic Native package for each plugin you want to add. Please see the [Ionic Native documentation](https://ionicframework.com/docs/native/) for complete instructions on how to add and use the plugins.
 
 ## Documentation
 
-For the full Ionic Native documentation, please visit [http://ionicframework.com/docs/native/](http://ionicframework.com/docs/native/).
+For the full Ionic Native documentation, please visit [https://ionicframework.com/docs/native/](https://ionicframework.com/docs/native/).
 
 ### Basic Usage
 
+#### Ionic/Angular apps
+
 To use a plugin, import and add the plugin provider to your `@NgModule`, and then inject it where you wish to use it.
+Make sure to import the injectable class from the `/ngx` directory as shown in the following examples:
 
 ```typescript
 // app.module.ts
-import { Camera } from '@ionic-native/camera';
+import { Camera } from '@ionic-native/camera/ngx';
 
 ...
 
@@ -44,42 +55,29 @@ export class AppModule { }
 ```
 
 ```typescript
-import { Geolocation } from '@ionic-native/geolocation';
+import { Geolocation } from '@ionic-native/geolocation/ngx';
 import { Platform } from 'ionic-angular';
 
-import { NgZone } from '@angular/core';
-
 @Component({ ... })
 export class MyComponent {
 
-  constructor(private geolocation: Geolocation, private platform: Platform, private ngZone: NgZone) {
+  constructor(private geolocation: Geolocation, private platform: Platform) {
 
-    platform.ready().then(() => {
+    this.platform.ready().then(() => {
 
       // get position
-      geolocation.getCurrentPosition().then(pos => {
-
+      this.geolocation.getCurrentPosition().then(pos => {
         console.log(`lat: ${pos.coords.latitude}, lon: ${pos.coords.longitude}`)
-
       });
 
 
       // watch position
       const watch = geolocation.watchPosition().subscribe(pos => {
-
         console.log(`lat: ${pos.coords.latitude}, lon: ${pos.coords.longitude}`)
-
-        // Currently, observables from Ionic Native plugins
-        // need to run inside of zone to trigger change detection
-        ngZone.run(() => {
-          this.position = pos;
-        })
-
       });
 
       // to stop watching
       watch.unsubscribe();
-
     });
 
   }
@@ -87,16 +85,116 @@ export class MyComponent {
 }
 ```
 
-### Mocking and Browser Development
+#### Ionic/React apps
 
-Ionic Native 3.x makes it possible to mock plugins and develop nearly the entirety of your app in the browser or in `ionic serve`.
+React apps must use Capacitor to build native mobile apps. However, Ionic Native (and therefore, Cordova plugins) can still be used.
+
+```bash
+# Install Core library (once per project)
+npm install @ionic-native/core
+
+# Install Ionic Native TypeScript wrapper
+npm install @ionic-native/barcode-scanner
+
+# Install Cordova plugin
+npm install phonegap-plugin-barcodescanner
+
+# Update native platform project(s) to include newly added plugin
+ionic cap sync
+```
+
+Import the plugin object then use its static methods:
+
+```typescript
+import { BarcodeScanner } from '@ionic-native/barcode-scanner';
+
+const Tab1: React.FC = () => {
+  const openScanner = async () => {
+    const data = await BarcodeScanner.scan();
+    console.log(`Barcode data: ${data.text}`);
+  };
+  return (
+    <IonPage>
+      <IonHeader>
+        <IonToolbar>
+          <IonTitle>Tab 1</IonTitle>
+        </IonToolbar>
+      </IonHeader>
+      <IonContent>
+        <IonButton onClick={openScanner}>Scan barcode</IonButton>
+      </IonContent>
+    </IonPage>
+  );
+};
+```
+
+#### ES2015+/TypeScript
+
+These modules can work in any ES2015+/TypeScript app (including Angular/Ionic apps). To use any plugin, import the class from the appropriate package, and use it's static methods.
+
+```js
+import { Camera } from '@ionic-native/camera';
+
+document.addEventListener('deviceready', () => {
+  Camera.getPicture()
+    .then(data => console.log('Took a picture!', data))
+    .catch(e => console.log('Error occurred while taking a picture', e));
+});
+```
+
+#### AngularJS
+
+Ionic Native generates an AngularJS module in runtime and prepares a service for each plugin. To use the plugins in your AngularJS app:
+
+1. Download the latest bundle from the [Github releases](https://github.com/ionic-team/ionic-native/releases) page.
+2. Include it in `index.html` before your app's code.
+3. Inject `ionic.native` module in your app.
+4. Inject any plugin you would like to use with a `$cordova` prefix.
+
+```js
+angular.module('myApp', ['ionic.native']).controller('MyPageController', function ($cordovaCamera) {
+  $cordovaCamera.getPicture().then(
+    function (data) {
+      console.log('Took a picture!', data);
+    },
+    function (err) {
+      console.log('Error occurred while taking a picture', err);
+    }
+  );
+});
+```
+
+#### Vanilla JS
+
+To use Ionic Native in any other setup:
+
+1. Download the latest bundle from the [Github releases](https://github.com/ionic-team/ionic-native/releases) page.
+2. Include it in `index.html` before your app's code.
+3. Access any plugin using the global `IonicNative` variable.
+
+```js
+document.addEventListener('deviceready', function () {
+  IonicNative.Camera.getPicture().then(
+    function (data) {
+      console.log('Took a picture!', data);
+    },
+    function (err) {
+      console.log('Error occurred while taking a picture', err);
+    }
+  );
+});
+```
+
+### Mocking and Browser Development (Ionic/Angular apps only)
+
+Ionic Native makes it possible to mock plugins and develop nearly the entirety of your app in the browser or in `ionic serve`.
 
 To do this, you need to provide a mock implementation of the plugins you wish to use. Here's an example of mocking the `Camera` plugin to return a stock image while in development:
 
 First import the `Camera` class in your `src/app/app.module.ts` file:
 
 ```typescript
-import { Camera } from '@ionic-native/camera';
+import { Camera } from '@ionic-native/camera/ngx';
 ```
 
 Then create a new class that extends the `Camera` class with a mock implementation:
@@ -105,8 +203,8 @@ Then create a new class that extends the `Camera` class with a mock implementati
 class CameraMock extends Camera {
   getPicture(options) {
     return new Promise((resolve, reject) => {
-      resolve("BASE_64_ENCODED_DATA_GOES_HERE");
-    })
+      resolve('BASE_64_ENCODED_DATA_GOES_HERE');
+    });
   }
 }
 ```
@@ -114,75 +212,64 @@ class CameraMock extends Camera {
 Finally, override the previous `Camera` class in your `providers` for this module:
 
 ```typescript
-providers: [
-  { provide: Camera, useClass: CameraMock }
-]
+providers: [{ provide: Camera, useClass: CameraMock }];
 ```
 
 Here's the full example:
 
 ```typescript
-import { NgModule, ErrorHandler } from '@angular/core';
+import { ErrorHandler, NgModule } from '@angular/core';
 import { BrowserModule } from '@angular/platform-browser';
 import { IonicApp, IonicModule, IonicErrorHandler } from 'ionic-angular';
 import { MyApp } from './app.component';
 import { HomePage } from '../pages/home/home';
 
-import { Camera } from '@ionic-native/camera';
+import { Camera } from '@ionic-native/camera/ngx';
+
+import { HomePage } from '../pages/home/home';
+import { MyApp } from './app.component';
 
 class CameraMock extends Camera {
   getPicture(options) {
     return new Promise((resolve, reject) => {
-      resolve("BASE_64_ENCODED_DATA_GOES_HERE");
-    })
+      resolve('BASE_64_ENCODED_DATA_GOES_HERE');
+    });
   }
 }
 
 @NgModule({
-  declarations: [
-    MyApp,
-    HomePage
-  ],
-  imports: [
-    BrowserModule,
-    IonicModule.forRoot(MyApp)
-  ],
+  declarations: [MyApp, HomePage],
+  imports: [BrowserModule, IonicModule.forRoot(MyApp)],
   bootstrap: [IonicApp],
-  entryComponents: [
-    MyApp,
-    HomePage
-  ],
+  entryComponents: [MyApp, HomePage],
   providers: [
-    {provide: ErrorHandler, useClass: IonicErrorHandler},
-    { provide: Camera, useClass: CameraMock }
-  ]
+    { provide: ErrorHandler, useClass: IonicErrorHandler },
+    { provide: Camera, useClass: CameraMock },
+  ],
 })
 export class AppModule {}
 ```
 
-
 ### Runtime Diagnostics
 
 Spent way too long diagnosing an issue only to realize a plugin wasn't firing or installed? Ionic Native lets you know what the issue is and how you can resolve it.
 
-![img](http://ionic-io-assets.s3.amazonaws.com/ionic-native-console.png)
-
+![img](https://ionic-io-assets.s3.amazonaws.com/ionic-native-console.png)
 
 ## Plugin Missing?
-Let us know or submit a PR! Take a look at [the Developer Guide](https://github.com/driftyco/ionic-native/blob/master/DEVELOPER.md) for more on how to contribute. :heart:
 
-## Ionic V1/Angular 1 support
-
-For Ionic V1/Angular 1 support, please use version 2 of Ionic Native. See the [2.x README](https://github.com/driftyco/ionic-native/blob/8cd648db5cddd7bdbe2bd78839b19c620cc8c04c/README.md) for usage information.
+Let us know or submit a PR! Take a look at [the Developer Guide](https://github.com/ionic-team/ionic-native/blob/master/DEVELOPER.md) for more on how to contribute. :heart:
 
 # Credits
 
-Ibby Hadeed - [@ihadeed](http://github.com/ihadeed)
+Ibby Hadeed - [@ihadeed](https://github.com/ihadeed)
 
-Tim Lancina - [@timlancina](http://twitter.com/timlancina)
+Daniel Sogl - [@sogldaniel](https://twitter.com/sogldaniel)
+
+Tim Lancina - [@timlancina](https://twitter.com/timlancina)
 
 Mike Hartington - [@mhartington](https://twitter.com/mhartington)
 
-Max Lynch - [@maxlynch](http://twitter.com/maxlynch)
+Max Lynch - [@maxlynch](https://twitter.com/maxlynch)
 
 Rob Wormald - [@robwormald](https://twitter.com/robwormald)

circle.yml

@@ -1,38 +0,0 @@
-version: 2
-jobs:
-  build:
-    working_directory: ~/ionic-native/
-    docker:
-      - image: node:7
-    steps:
-      - checkout
-      - restore_cache:
-         key: ionic-site
-      - run:
-         name: Prepare ionic-site repo
-         command: ./scripts/docs/prepare.sh
-      - save_cache:
-         key: ionic-site
-         paths:
-         - ~/ionic-site/
-      - restore_cache:
-         key: node_modules_{{ checksum "package.json" }}
-      - run:
-         name: Install node modules
-         command: npm i
-      - save_cache:
-         key: node_modules_{{ checksum "package.json" }}
-         paths:
-         - ~/ionic-native/node_modules/
-      - run:
-          name: Run tslint
-          command: npm run lint
-      - add_ssh_keys
-      - deploy:
-          name: Update docs
-          command: |
-            if [ "${CIRCLE_BRANCH}" == "master" ]; then
-              ./scripts/docs/update_docs.sh
-            else
-              echo "We are on ${CIRCLE_BRANCH} branch, not going to update docs."
-            fi

gulpfile.js

@@ -1,49 +1,51 @@
-"use strict";
+'use strict';
 
 const gulp = require('gulp'),
   minimist = require('minimist'),
-  rename = require("gulp-rename"),
+  rename = require('gulp-rename'),
   tslint = require('gulp-tslint'),
-  decamelize = require('decamelize'),
   replace = require('gulp-replace'),
   _ = require('lodash');
 
 const flagConfig = {
     string: ['port', 'version', 'ngVersion', 'animations'],
     boolean: ['dry-run'],
-    alias: {'p': 'port', 'v': 'version', 'a': 'ngVersion'},
-    default: { port: 8000 }
+    alias: { p: 'port', v: 'version', a: 'ngVersion' },
+    default: { port: 8000 },
   },
-
   flags = minimist(process.argv.slice(2), flagConfig);
 
 /* Docs tasks */
 require('./scripts/docs/gulp-tasks')(gulp, flags);
 
 gulp.task('lint', () => {
-  return gulp.src('src/**/*.ts')
-    .pipe(tslint({
-      formatter: "verbose",
-      configuration: 'tslint.json'
-    }))
+  return gulp
+    .src('src/**/*.ts')
+    .pipe(
+      tslint({
+        formatter: 'verbose',
+        configuration: 'tslint.json',
+      })
+    )
     .pipe(tslint.report());
 });
 
 gulp.task('plugin:create', () => {
-  if (flags.n && flags.n !== ''){
-
-    const src = flags.m ? './scripts/templates/wrap-min.tmpl':'./scripts/templates/wrap.tmpl',
+  if (flags.n && flags.n !== '') {
+    const src = flags.m ? './scripts/templates/wrap-min.tmpl' : './scripts/templates/wrap.tmpl',
       pluginName = flags.n,
-      pluginNameSpaced = pluginName.replace(/(?!^)([A-Z])/g, ' $1');
+      spaced = pluginName.replace(/(?!^)([A-Z])/g, ' $1'),
+      kebabCase = _.kebabCase(pluginName);
 
-    return gulp.src(src)
-      .pipe(replace('$PluginName', pluginName))
-      .pipe(replace('$Plugin_Name', pluginNameSpaced))
-      .pipe(replace('$pluginName', _.lowerFirst(pluginName)))
+    return gulp
+      .src(src)
+      .pipe(replace('{{ PluginName }}', pluginName))
+      .pipe(replace('{{ Plugin_Name }}', spaced))
+      .pipe(replace('{{ pluginName }}', _.lowerFirst(pluginName)))
+      .pipe(replace('{{ plugin-name }}', kebabCase))
       .pipe(rename('index.ts'))
-      .pipe(gulp.dest('./src/@ionic-native/plugins/' + _.kebabCase(pluginName)));
-
+      .pipe(gulp.dest('./src/@ionic-native/plugins/' + kebabCase));
   } else {
-    console.log("Usage is: gulp plugin:create -n PluginName");
+    console.log('Usage is: gulp plugin:create -n PluginName');
   }
 });

ignore-circle.yml

@@ -0,0 +1,51 @@
+version: 2
+jobs:
+  build:
+    working_directory: ~/ionic-native/
+    docker:
+      - image: node:14
+    steps:
+      - checkout
+      - restore_cache:
+          key: ionic-site-{{ checksum "package.json" }}
+      - run:
+          name: Prepare ionic-site repo
+          command: |
+            if [ "${CIRCLE_BRANCH}" == "master" ]; then
+              ./scripts/docs/prepare.sh
+            fi
+      - save_cache:
+          key: ionic-site-{{ checksum "package.json" }}
+          paths:
+            - ~/ionic-site/
+      - restore_cache:
+          key: node_modules_{{ checksum "package.json" }}
+      - run:
+          name: Install node modules
+          command: npm ci
+      - save_cache:
+          key: node_modules_{{ checksum "package.json" }}
+          paths:
+            - ~/ionic-native/node_modules/
+      - run:
+          name: Run tslint
+          command: npm run lint
+      - run: bash ./scripts/git/config.sh
+      - run:
+          name: Build Ionic Native
+          command: npm run build
+      - run:
+          name: Generate README files to ensure docs are valid
+          command: npm run readmes
+      - run:
+          name: Run tests
+          command: npm test
+      - add_ssh_keys
+      - deploy:
+          name: Update docs
+          command: |
+            if [ "${CIRCLE_BRANCH}" == "master" ]; then
+              ./scripts/docs/update_docs.sh
+            else
+              echo "We are on ${CIRCLE_BRANCH} branch, not going to update docs."
+            fi

package.json

@@ -1,54 +1,107 @@
 {
   "name": "ionic-native",
-  "version": "3.7.0",
+  "version": "5.36.0",
   "description": "Native plugin wrappers for Cordova and Ionic with TypeScript, ES6+, Promise and Observable support",
+  "homepage": "https://ionicframework.com/",
+  "author": "Ionic Team <hi@ionic.io> (https://ionic.io)",
   "license": "MIT",
-  "devDependencies": {
-    "@angular/compiler": "4.0.0",
-    "@angular/compiler-cli": "4.0.0",
-    "@angular/core": "4.0.0",
-    "canonical-path": "0.0.2",
-    "child-process-promise": "2.2.0",
-    "conventional-changelog-cli": "1.2.0",
-    "cpr": "2.0.2",
-    "cz-conventional-changelog": "1.2.0",
-    "decamelize": "1.2.0",
-    "dgeni": "0.4.7",
-    "dgeni-packages": "0.16.10",
-    "fs-extra": "2.0.0",
-    "fs-extra-promise": "0.4.1",
-    "gulp": "3.9.1",
-    "gulp-rename": "1.2.2",
-    "gulp-replace": "0.5.4",
-    "gulp-tslint": "6.1.2",
-    "lodash": "4.17.4",
-    "minimist": "1.1.3",
-    "node-html-encoder": "0.0.2",
-    "q": "1.4.1",
-    "queue": "4.2.1",
-    "rimraf": "2.5.4",
-    "rxjs": "5.1.1",
-    "semver": "5.3.0",
-    "tslint": "3.15.1",
-    "tslint-ionic-rules": "0.0.7",
-    "typescript": "2.2.1",
-    "zone.js": "^0.8.4"
-  },
   "scripts": {
-    "start": "npm run test:watch",
+    "prepare": "is-ci || husky install",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "build:core": "tsc -p tsconfig.core.json",
+    "build:esm": "ts-node -P scripts/tsconfig.json scripts/tasks/build-esm",
+    "build:es5": "ts-node -P scripts/tsconfig.json scripts/tasks/build-es5",
+    "build:ngx": "ts-node -P scripts/tsconfig.json scripts/tasks/build-ngx",
+    "build": "npm run build:core && npm run build:esm && npm run build:ngx && npm run build:es5",
+    "prebuild": "rimraf -rf dist",
+    "npmpub": "ts-node -P scripts/tsconfig.json scripts/tasks/publish",
     "lint": "gulp lint",
-    "build": "npm run clean && npm run lint && npm run build:core && npm run build:modules",
-    "build:core": "ngc -p scripts/build/tsconfig-core.json",
-    "build:modules": "node scripts/build/build.js",
-    "clean": "rimraf dist .tmp",
-    "shipit": "npm run build && gulp readmes && npm run npmpub",
-    "npmpub": "node scripts/build/publish.js",
-    "changelog": "conventional-changelog -p angular -i CHANGELOG.md -s -r 0",
-    "postchangelog": "git commit -am \"chore(): update changelog\""
+    "readmes": "gulp readmes",
+    "docs-json": "ts-node -P scripts/tsconfig.json scripts/docs-json",
+    "version": "conventional-changelog -p angular -i CHANGELOG.md -s -r 0 && git add CHANGELOG.md",
+    "shipit": "npm run build && npm run readmes && npm run npmpub",
+    "prettier": "prettier src/**/* --write"
+  },
+  "dependencies": {
+    "tslib": "^2.3.1"
+  },
+  "devDependencies": {
+    "@angular/common": "^11.2.14",
+    "@angular/compiler": "^11.2.14",
+    "@angular/compiler-cli": "^11.2.14",
+    "@angular/core": "^11.2.14",
+    "@types/cordova": "0.0.34",
+    "@types/fs-extra": "^9.0.12",
+    "@types/jest": "^26.0.24",
+    "@types/lodash": "^4.14.172",
+    "@types/node": "^12.20.19",
+    "@types/rimraf": "^3.0.2",
+    "@types/webpack": "^5.28.0",
+    "async-promise-queue": "^1.0.5",
+    "conventional-changelog-cli": "^2.1.1",
+    "cz-conventional-changelog": "^3.3.0",
+    "dgeni": "^0.4.14",
+    "dgeni-packages": "0.16.10",
+    "fs-extra": "^10.0.0",
+    "gulp": "^4.0.2",
+    "gulp-rename": "^2.0.0",
+    "gulp-replace": "^1.1.3",
+    "gulp-tslint": "^8.1.4",
+    "husky": "^7.0.1",
+    "is-ci": "^3.0.0",
+    "jest": "^27.0.6",
+    "lint-staged": "^11.1.2",
+    "lodash": "^4.17.21",
+    "minimist": "^1.2.5",
+    "natives": "^1.1.6",
+    "prettier": "^2.3.2",
+    "rimraf": "^3.0.2",
+    "rollup": "^2.56.2",
+    "rxjs": "^6.6.7",
+    "ts-jest": "^27.0.5",
+    "ts-node": "^10.2.1",
+    "tslint": "~6.1.0",
+    "tslint-config-prettier": "^1.18.0",
+    "tslint-ionic-rules": "0.0.21",
+    "typedoc": "^0.18.0",
+    "typescript": "4.1.6",
+    "typescript-tslint-plugin": "^1.0.1",
+    "uglifyjs-webpack-plugin": "^2.2.0",
+    "unminified-webpack-plugin": "^3.0.0",
+    "webpack": "^5.51.1",
+    "winston": "^3.3.3",
+    "zone.js": "^0.11.4"
+  },
+  "jest": {
+    "testEnvironment": "jsdom",
+    "transform": {
+      "^.+\\.tsx?$": "ts-jest"
+    },
+    "testRegex": "(/__tests__/.*|(\\.|/)(test|spec))\\.(js?|ts?)$",
+    "moduleFileExtensions": [
+      "ts",
+      "tsx",
+      "js",
+      "jsx",
+      "json"
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ionic-team/ionic-native.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ionic-team/ionic-native/issues"
   },
   "config": {
     "commitizen": {
       "path": "./node_modules/cz-conventional-changelog"
     }
+  },
+  "lint-staged": {
+    "*": [
+      "prettier src/**/* --write"
+    ]
   }
 }

prettier.config.js

@@ -0,0 +1,16 @@
+module.exports = {
+  printWidth: 120,
+  tabWidth: 2,
+  useTabs: false,
+  semi: true,
+  singleQuote: true,
+  trailingComma: 'es5',
+  bracketSpacing: true,
+  jsxBracketSameLine: false,
+  arrowParens: 'avoid',
+  rangeStart: 0,
+  rangeEnd: Infinity,
+  requirePragma: false,
+  insertPragma: false,
+  proseWrap: 'preserve',
+};

scripts/build/build.js

@@ -1,133 +0,0 @@
-"use strict";
-// Node module dependencies
-const fs = require('fs-extra-promise').useFs(require('fs-extra')),
-  queue = require('queue'),
-  path = require('path'),
-  exec = require('child_process').exec;
-
-// Constants for the build process. Paths and JSON files templates
-const ROOT = path.resolve(path.join(__dirname, '../../')), // root ionic-native directory
-  PLUGINS_PATH = path.resolve(ROOT, 'src/@ionic-native/plugins'), // path to plugins source files
-  CORE_PACKAGE_JSON = require(path.resolve(__dirname, 'core-package.json')), // core package.json
-  PLUGIN_PACKAGE_JSON = require(path.resolve(__dirname, 'plugin-package.json')), // plugin package.json template
-  PLUGIN_TS_CONFIG = require(path.resolve(__dirname, 'tsconfig-plugin.json')), // plugin tsconfig template
-  BUILD_TMP = path.resolve(ROOT, '.tmp'), // tmp directory path
-  BUILD_DIST_ROOT = path.resolve(ROOT, 'dist/@ionic-native'), // dist directory root path
-  BUILD_CORE_DIST = path.resolve(BUILD_DIST_ROOT, 'core'); // core dist directory path
-
-
-// dependency versions
-const ANGULAR_VERSION = '*',
-  RXJS_VERSION = '^5.0.1',
-  MIN_CORE_VERSION = '^3.6.0',
-  IONIC_NATIVE_VERSION = require(path.resolve(ROOT, 'package.json')).version;
-
-// package dependencies
-const CORE_PEER_DEPS = {
-  'rxjs': RXJS_VERSION
-};
-
-const PLUGIN_PEER_DEPS = {
-  '@ionic-native/core': MIN_CORE_VERSION,
-  '@angular/core': ANGULAR_VERSION,
-  'rxjs': RXJS_VERSION
-};
-
-// set peer dependencies for all plugins
-PLUGIN_PACKAGE_JSON.peerDependencies = PLUGIN_PEER_DEPS;
-
-// Create tmp/dist directories
-console.log('Making new TMP directory');
-fs.mkdirpSync(BUILD_TMP);
-
-// Prepare and copy the core module's package.json
-console.log('Preparing core module package.json');
-CORE_PACKAGE_JSON.version = IONIC_NATIVE_VERSION;
-CORE_PACKAGE_JSON.peerDependencies = CORE_PEER_DEPS;
-fs.writeJsonSync(path.resolve(BUILD_CORE_DIST, 'package.json'), CORE_PACKAGE_JSON);
-
-
-// Fetch a list of the plugins
-const PLUGINS = fs.readdirSync(PLUGINS_PATH);
-
-// Build specific list of plugins to build from arguments, if any
-let pluginsToBuild = process.argv.slice(2);
-if (!pluginsToBuild.length) {
-  pluginsToBuild = PLUGINS;
-}
-
-// Create a queue to process tasks
-const QUEUE = queue({
-  concurrency: require('os').cpus().length
-});
-
-
-// Function to process a single plugin
-const addPluginToQueue = pluginName => {
-
-  QUEUE.push((callback) => {
-
-    console.log(`Building plugin: ${pluginName}`);
-
-    const PLUGIN_BUILD_DIR = path.resolve(BUILD_TMP, 'plugins', pluginName),
-      PLUGIN_SRC_PATH = path.resolve(PLUGINS_PATH, pluginName, 'index.ts');
-
-    let tsConfigPath;
-
-    fs.mkdirpAsync(PLUGIN_BUILD_DIR) // create tmp build dir
-      .then(() => fs.mkdirpAsync(path.resolve(BUILD_DIST_ROOT, pluginName))) // create dist dir
-      .then(() => {
-
-        // Write tsconfig.json
-        const tsConfig = JSON.parse(JSON.stringify(PLUGIN_TS_CONFIG));
-        tsConfig.files = [PLUGIN_SRC_PATH];
-        // tsConfig.compilerOptions.paths['@ionic-native/core'] = [BUILD_CORE_DIST];
-
-        tsConfigPath = path.resolve(PLUGIN_BUILD_DIR, 'tsconfig.json');
-
-        return fs.writeJsonAsync(tsConfigPath, tsConfig);
-      })
-      .then(() => {
-        // clone package.json
-        const packageJson = JSON.parse(JSON.stringify(PLUGIN_PACKAGE_JSON));
-
-        packageJson.name = `@ionic-native/${pluginName}`;
-        packageJson.version = IONIC_NATIVE_VERSION;
-
-        return fs.writeJsonAsync(path.resolve(BUILD_DIST_ROOT, pluginName, 'package.json'), packageJson);
-      })
-      .then(() => {
-
-        // compile the plugin
-        exec(`${ROOT}/node_modules/.bin/ngc -p ${tsConfigPath}`, (err, stdout, stderr) => {
-
-          if (err) {
-            // oops! something went wrong.
-            callback(`\n\nBuilding ${pluginName} failed.`);
-            console.log(err);
-            return;
-          }
-
-          // we're done with this plugin!
-          callback();
-
-        });
-
-      })
-      .catch(callback);
-
-  }); // QUEUE.push end
-
-};
-
-pluginsToBuild.forEach(addPluginToQueue);
-
-QUEUE.start((err) => {
-
-  if (err) {
-    console.log('Error building plugins. ', err);
-  } else {
-    console.log('Done processing plugins!');
-  }
-
-});

scripts/build/core-package.json

@@ -1,14 +0,0 @@
-{
-  "name": "@ionic-native/core",
-  "version": "{{VERSION}}",
-  "description": "Ionic Native - Native plugins for ionic apps",
-  "module": "index.js",
-  "typings": "index.d.ts",
-  "author": "ionic",
-  "license": "MIT",
-  "peerDependencies": {},
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/driftyco/ionic-native.git"
-  }
-}

scripts/build/helpers.ts

@@ -0,0 +1,136 @@
+import * as ts from 'typescript';
+import * as fs from 'fs-extra';
+import * as path from 'path';
+import { camelCase, clone } from 'lodash';
+import { Logger } from '../logger';
+
+export const ROOT = path.resolve(__dirname, '../../');
+// tslint:disable-next-line:no-var-requires
+export const TS_CONFIG = clone(require(path.resolve(ROOT, 'tsconfig.json')));
+export const COMPILER_OPTIONS = TS_CONFIG.compilerOptions;
+export const PLUGINS_ROOT = path.join(ROOT, 'src/@ionic-native/plugins/');
+export const PLUGIN_PATHS = fs.readdirSync(PLUGINS_ROOT).map(d => path.join(PLUGINS_ROOT, d, 'index.ts'));
+
+export function getDecorator(node: ts.Node, index = 0): ts.Decorator {
+  if (node.decorators && node.decorators[index]) {
+    return node.decorators[index];
+  }
+}
+
+export function hasDecorator(decoratorName: string, node: ts.Node): boolean {
+  return (
+    node.decorators &&
+    node.decorators.length &&
+    node.decorators.findIndex(d => getDecoratorName(d) === decoratorName) > -1
+  );
+}
+
+export function getDecoratorName(decorator: any) {
+  return decorator.expression.expression.text;
+}
+
+export function getRawDecoratorArgs(decorator: any): any[] {
+  if (decorator.expression.arguments.length === 0) return [];
+  return decorator.expression.arguments[0].properties;
+}
+
+export function getDecoratorArgs(decorator: any) {
+  const properties: any[] = getRawDecoratorArgs(decorator);
+  const args = {};
+
+  properties.forEach(prop => {
+    let val: number | boolean;
+
+    switch (prop.initializer.kind) {
+      case ts.SyntaxKind.StringLiteral:
+      case ts.SyntaxKind.Identifier:
+        val = prop.initializer.text;
+        break;
+
+      case ts.SyntaxKind.ArrayLiteralExpression:
+        val = prop.initializer.elements.map((e: any) => e.text);
+        break;
+
+      case ts.SyntaxKind.TrueKeyword:
+        val = true;
+        break;
+
+      case ts.SyntaxKind.FalseKeyword:
+        val = false;
+        break;
+
+      case ts.SyntaxKind.NumericLiteral:
+        val = Number(prop.initializer.text);
+        break;
+
+      default:
+        Logger.debug('Unexpected property value type: ' + prop.initializer.kind);
+        throw new Error('Unexpected property value type << helpers.ts >>');
+    }
+
+    args[prop.name.text] = val;
+  });
+
+  return args;
+}
+
+/**
+ * FROM STENCIL
+ * Convert a js value into typescript AST
+ * @param val array, object, string, boolean, or number
+ * @returns Typescript Object Literal, Array Literal, String Literal, Boolean Literal, Numeric Literal
+ */
+export function convertValueToLiteral(val: any) {
+  if (Array.isArray(val)) {
+    return arrayToArrayLiteral(val);
+  }
+  if (typeof val === 'object') {
+    return objectToObjectLiteral(val);
+  }
+  if (typeof val === 'number') {
+    return ts.createNumericLiteral(String(val));
+  }
+  return ts.createLiteral(val);
+}
+
+/**
+ * FROM STENCIL
+ * Convert a js object into typescript AST
+ * @param obj key value object
+ * @returns Typescript Object Literal Expression
+ */
+function objectToObjectLiteral(obj: { [key: string]: any }): ts.ObjectLiteralExpression {
+  const newProperties: ts.ObjectLiteralElementLike[] = Object.keys(obj).map(
+    (key: string): ts.ObjectLiteralElementLike => {
+      return ts.createPropertyAssignment(ts.createLiteral(key), convertValueToLiteral(obj[key]) as ts.Expression);
+    }
+  );
+
+  return ts.createObjectLiteral(newProperties);
+}
+
+/**
+ * FROM STENCIL
+ * Convert a js array into typescript AST
+ * @param list array
+ * @returns Typescript Array Literal Expression
+ */
+function arrayToArrayLiteral(list: any[]): ts.ArrayLiteralExpression {
+  const newList: any[] = list.map(convertValueToLiteral);
+  return ts.createArrayLiteral(newList);
+}
+
+export function getMethodsForDecorator(decoratorName: string) {
+  switch (decoratorName) {
+    case 'CordovaProperty':
+      return ['cordovaPropertyGet', 'cordovaPropertySet'];
+    case 'InstanceProperty':
+      return ['instancePropertyGet', 'instancePropertySet'];
+    case 'CordovaCheck':
+      return ['checkAvailability'];
+    case 'InstanceCheck':
+      return ['instanceAvailability'];
+  }
+
+  return [camelCase(decoratorName)];
+}

scripts/build/ngx.ts

@@ -0,0 +1,132 @@
+import * as ts from 'typescript';
+import * as fs from 'fs-extra';
+import * as path from 'path';
+import * as rimraf from 'rimraf';
+import * as rollup from 'rollup';
+import { generateDeclarations } from './transpile';
+import { clone } from 'lodash';
+import { EmitFlags, createCompilerHost, CompilerOptions, CompilerHost, createProgram } from '@angular/compiler-cli';
+import { importsTransformer } from './transformers/imports';
+import { pluginClassTransformer } from './transformers/plugin-class';
+import { COMPILER_OPTIONS, PLUGIN_PATHS, ROOT } from './helpers';
+
+export function getProgram(rootNames: string[] = createSourceFiles()) {
+  const options: CompilerOptions = clone(COMPILER_OPTIONS);
+  options.basePath = ROOT;
+  options.moduleResolution = ts.ModuleResolutionKind.NodeJs;
+  options.module = ts.ModuleKind.ES2015;
+  options.target = ts.ScriptTarget.ES5;
+  options.lib = ['dom', 'es2017'];
+  options.inlineSourceMap = true;
+  options.importHelpers = true;
+  options.inlineSources = true;
+  options.enableIvy = false;
+
+  delete options.baseUrl;
+
+  const host: CompilerHost = createCompilerHost({ options });
+  return createProgram({
+    rootNames,
+    options,
+    host,
+  });
+}
+
+// hacky way to export metadata only for core package
+export function transpileNgxCore() {
+  getProgram([path.resolve(ROOT, 'src/@ionic-native/core/index.ts')]).emit({
+    emitFlags: EmitFlags.Metadata,
+    emitCallback: ({ program, writeFile, customTransformers, cancellationToken, targetSourceFile }) => {
+      return program.emit(targetSourceFile, writeFile, cancellationToken, true, customTransformers);
+    },
+  });
+}
+
+export function transpileNgx() {
+  getProgram().emit({
+    emitFlags: EmitFlags.Metadata,
+    customTransformers: {
+      beforeTs: [importsTransformer(true), pluginClassTransformer(true)],
+    },
+  });
+}
+
+export function generateDeclarationFiles() {
+  generateDeclarations(PLUGIN_PATHS.map(p => p.replace('index.ts', 'ngx/index.ts')));
+}
+
+export function generateLegacyBundles() {
+  [
+    path.resolve(ROOT, 'dist/@ionic-native/core/index.js'),
+    ...PLUGIN_PATHS.map(p =>
+      p.replace(path.join(ROOT, 'src'), path.join(ROOT, 'dist')).replace('index.ts', 'ngx/index.js')
+    ),
+  ].forEach(p =>
+    rollup
+      .rollup({
+        input: p,
+        onwarn(warning, warn) {
+          if (warning.code === 'UNUSED_EXTERNAL_IMPORT') return;
+          warn(warning);
+        },
+        external: ['@angular/core', '@ionic-native/core', 'rxjs', 'tslib'],
+      })
+      .then(bundle =>
+        bundle.write({
+          file: path.join(path.dirname(p), 'bundle.js'),
+          format: 'cjs',
+        })
+      )
+  );
+}
+
+// remove reference to @ionic-native/core decorators
+export function modifyMetadata() {
+  debugger;
+  PLUGIN_PATHS.map(p =>
+    p.replace(path.join(ROOT, 'src'), path.join(ROOT, 'dist')).replace('index.ts', 'ngx/index.metadata.json')
+  ).forEach(p => {
+    const content = fs.readJSONSync(p);
+    let _prop: { members: { [x: string]: any[] } };
+    for (const prop in content[0].metadata) {
+      _prop = content[0].metadata[prop];
+      removeIonicNativeDecorators(_prop);
+
+      if (_prop.members) {
+        for (const memberProp in _prop.members) {
+          removeIonicNativeDecorators(_prop.members[memberProp][0]);
+        }
+      }
+    }
+
+    fs.writeJSONSync(p, content);
+  });
+}
+
+function removeIonicNativeDecorators(node: any) {
+  if (node.decorators && node.decorators.length) {
+    node.decorators = node.decorators.filter(
+      (d: { expression: { module: string } }) => d.expression.module !== '@ionic-native/core'
+    );
+  }
+
+  if (node.decorators && !node.decorators.length) delete node.decorators;
+}
+
+function createSourceFiles(): string[] {
+  return PLUGIN_PATHS.map((indexPath: string) => {
+    const ngxPath = path.resolve(indexPath.replace('index.ts', ''), 'ngx'),
+      newPath = path.resolve(ngxPath, 'index.ts');
+
+    // delete directory
+    rimraf.sync(ngxPath);
+    fs.mkdirpSync(ngxPath);
+    fs.copyFileSync(indexPath, newPath);
+
+    return newPath;
+  });
+}
+
+export function cleanupNgx() {
+  PLUGIN_PATHS.forEach((indexPath: string) => rimraf.sync(indexPath.replace('index.ts', 'ngx')));
+}

scripts/build/plugin-package.json

@@ -1,14 +0,0 @@
-{
-  "name": "@ionic-native/{{PLUGIN}}",
-  "version": "{{VERSION}}",
-  "description": "Ionic Native - Native plugins for ionic apps",
-  "module": "index.js",
-  "typings": "index.d.ts",
-  "author": "ionic",
-  "license": "MIT",
-  "peerDependencies": {},
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/driftyco/ionic-native.git"
-  }
-}

scripts/build/publish.js

@@ -1,58 +0,0 @@
-"use strict";
-// Node module dependencies
-const fs = require('fs-extra-promise').useFs(require('fs-extra')),
-  queue = require('queue'),
-  path = require('path'),
-  exec = require('child-process-promise').exec;
-
-
-const ROOT = path.resolve(path.join(__dirname, '../../')),
-  DIST = path.resolve(ROOT, 'dist', '@ionic-native');
-
-const FLAGS = '--access public'; // add any flags here if you want... (example: --tag alpha)
-
-const PACKAGES = fs.readdirSync(DIST);
-
-const failedPackages = [];
-
-const QUEUE = queue({
-  concurrency: 10
-});
-
-PACKAGES.forEach(packageName => {
-
-  QUEUE.push(done => {
-
-    console.log(`Publishing @ionic-native/${packageName}`);
-    const packagePath = path.resolve(DIST, packageName);
-    exec(`npm publish ${packagePath} ${FLAGS}`)
-      .then(() => done())
-      .catch((e) => {
-        if (e.stderr && e.stderr.indexOf('previously published version') === -1) {
-          failedPackages.push({
-            cmd: e.cmd,
-            stderr: e.stderr
-          });
-        }
-        done();
-      });
-
-  });
-
-});
-
-QUEUE.start((err) => {
-
-  if (err) {
-    console.log('Error publishing ionic-native. ', err);
-  } else if (failedPackages.length > 0) {
-    console.log(`${failedPackages.length} packages failed to publish.`);
-    console.log(failedPackages);
-  } else {
-    console.log('Done publishing ionic-native!');
-  }
-
-
-
-});
-

scripts/build/remove-tslib-helpers.js

@@ -0,0 +1,2 @@
+// removes the __extends method that is added automatically by typescript
+module.exports = source => source.replace(/var\s__extends\s=\s\(this\s&&[\sa-z\._\(\)\|{}=:\[\]&,;?]+}\)\(\);/i, '');

scripts/build/transformers/extract-injectables.ts

@@ -0,0 +1,59 @@
+import * as fs from 'fs-extra';
+import * as path from 'path';
+import * as ts from 'typescript';
+
+import { hasDecorator, ROOT } from '../helpers';
+
+export interface InjectableClassEntry {
+  file: string;
+  className: string;
+  dirName: string;
+}
+
+const injectableClasses: InjectableClassEntry[] = [];
+export const EMIT_PATH = path.resolve(ROOT, 'injectable-classes.json');
+
+/**
+ * This transformer extracts all the injectable classes
+ * so we can use all the names later on when we compile
+ * an es5 bundle.
+ *
+ * Every injectable class will end up in the
+ * window['IonicNative'] object.
+ */
+export function extractInjectables() {
+  return (ctx: ts.TransformationContext) => {
+    return tsSourceFile => {
+      if (tsSourceFile.fileName.indexOf('src/@ionic-native/plugins') > -1) {
+        ts.visitEachChild(
+          tsSourceFile,
+          node => {
+            if (node.kind !== ts.SyntaxKind.ClassDeclaration) {
+              return node;
+            }
+
+            const isInjectable: boolean = hasDecorator('Injectable', node);
+            if (isInjectable) {
+              injectableClasses.push({
+                file: tsSourceFile.path,
+                className: (node as ts.ClassDeclaration).name.text,
+                dirName: tsSourceFile.path.split(/[\\\/]+/).reverse()[1],
+              });
+            }
+          },
+          ctx
+        );
+      }
+
+      return tsSourceFile;
+    };
+  };
+}
+
+export function emitInjectableClasses() {
+  fs.writeJSONSync(EMIT_PATH, injectableClasses);
+}
+
+export function cleanEmittedData() {
+  fs.unlinkSync(EMIT_PATH);
+}

scripts/build/transformers/imports.ts

@@ -0,0 +1,77 @@
+import * as ts from 'typescript';
+import { getMethodsForDecorator } from '../helpers';
+
+function transformImports(file: ts.SourceFile, ctx: ts.TransformationContext, ngcBuild?: boolean) {
+  // remove angular imports
+  if (!ngcBuild) {
+    // @ts-expect-error
+    file.statements = (file.statements as any).filter(
+      (s: any) => !(s.kind === ts.SyntaxKind.ImportDeclaration && s.moduleSpecifier.text === '@angular/core')
+    );
+  }
+
+  // find the @ionic-native/core import statement
+  const importStatement = (file.statements as any).find((s: any) => {
+    return s.kind === ts.SyntaxKind.ImportDeclaration && s.moduleSpecifier.text === '@ionic-native/core';
+  });
+
+  // we're only interested in files containing @ionic-native/core import statement
+  if (!importStatement) return file;
+
+  const decorators: string[] = [];
+
+  const decoratorRegex: RegExp = /@([a-zA-Z]+)\(/g;
+
+  const ignored: string[] = ['Plugin', 'Component', 'Injectable'];
+
+  const keep: string[] = ['getPromise', 'checkAvailability'];
+
+  let m;
+
+  while ((m = decoratorRegex.exec(file.text)) !== null) {
+    if (m.index === decoratorRegex.lastIndex) {
+      decoratorRegex.lastIndex++;
+    }
+    if (m && m[1] && decorators.indexOf(m[1]) === -1 && ignored.indexOf(m[1]) === -1) decorators.push(m[1]);
+  }
+
+  if (decorators.length) {
+    let methods = [];
+
+    decorators.forEach(d => (methods = getMethodsForDecorator(d).concat(methods)));
+
+    const methodElements = methods.map(m => ts.createIdentifier(m));
+    const methodNames = methodElements.map(el => el.escapedText);
+
+    importStatement.importClause.namedBindings.elements = [
+      ts.createIdentifier('IonicNativePlugin'),
+      ...methodElements,
+      ...importStatement.importClause.namedBindings.elements.filter(
+        el => keep.indexOf(el.name.text) !== -1 && methodNames.indexOf(el.name.text) === -1
+      ),
+    ];
+
+    if (ngcBuild) {
+      importStatement.importClause.namedBindings.elements = importStatement.importClause.namedBindings.elements.map(
+        binding => {
+          if (binding.escapedText) {
+            binding.name = {
+              text: binding.escapedText,
+            };
+          }
+          return binding;
+        }
+      );
+    }
+  }
+
+  return file;
+}
+
+export function importsTransformer(ngcBuild?: boolean) {
+  return (ctx: ts.TransformationContext) => {
+    return tsSourceFile => {
+      return transformImports(tsSourceFile, ctx, ngcBuild);
+    };
+  };
+}

scripts/build/transformers/members.ts

@@ -0,0 +1,33 @@
+import * as ts from 'typescript';
+import { transformMethod } from './methods';
+import { transformProperty } from './properties';
+
+export function transformMembers(cls: ts.ClassDeclaration) {
+  const propertyIndices: number[] = [];
+
+  const members = cls.members.map((member: any, index: number) => {
+    // only process decorated members
+    if (!member.decorators || !member.decorators.length) return member;
+
+    switch (member.kind) {
+      case ts.SyntaxKind.MethodDeclaration:
+        return transformMethod(member);
+      case ts.SyntaxKind.PropertyDeclaration:
+        propertyIndices.push(index);
+        return member;
+      case ts.SyntaxKind.Constructor:
+        return ts.createConstructor(undefined, undefined, member.parameters, member.body);
+      default:
+        return member; // in case anything gets here by accident...
+    }
+  });
+
+  propertyIndices.forEach((i: number) => {
+    const [getter, setter] = transformProperty(members, i) as any;
+    members.push(getter, setter);
+  });
+
+  propertyIndices.reverse().forEach(i => members.splice(i, 1));
+
+  return members;
+}

scripts/build/transformers/methods.ts

@@ -0,0 +1,62 @@
+import * as ts from 'typescript';
+import { Logger } from '../../logger';
+import {
+  convertValueToLiteral,
+  getDecorator,
+  getDecoratorArgs,
+  getDecoratorName,
+  getMethodsForDecorator,
+} from '../helpers';
+
+export function transformMethod(method: ts.MethodDeclaration) {
+  if (!method) return;
+
+  const decorator = getDecorator(method),
+    decoratorName = getDecoratorName(decorator),
+    decoratorArgs = getDecoratorArgs(decorator);
+
+  try {
+    return ts.createMethod(
+      undefined,
+      undefined,
+      undefined,
+      method.name,
+      undefined,
+      method.typeParameters,
+      method.parameters,
+      method.type,
+      ts.createBlock([ts.createReturn(getMethodBlock(method, decoratorName, decoratorArgs))])
+    );
+  } catch (e) {
+    Logger.error('Error transforming method: ' + (method.name as any).text);
+    Logger.error(e.message);
+  }
+}
+
+function getMethodBlock(method: ts.MethodDeclaration, decoratorName: string, decoratorArgs: any): ts.Expression {
+  const decoratorMethod = getMethodsForDecorator(decoratorName)[0];
+
+  switch (decoratorName) {
+    case 'CordovaCheck':
+    case 'InstanceCheck':
+      // TODO remove function wrapper
+      return ts.createImmediatelyInvokedArrowFunction([
+        ts.createIf(
+          ts.createBinary(
+            ts.createCall(ts.createIdentifier(decoratorMethod), undefined, [ts.createThis()]),
+            ts.SyntaxKind.EqualsEqualsEqualsToken,
+            ts.createTrue()
+          ),
+          method.body
+        ),
+      ]);
+
+    default:
+      return ts.createCall(ts.createIdentifier(decoratorMethod), undefined, [
+        ts.createThis(),
+        ts.createLiteral(decoratorArgs?.methodName || (method.name as any).text),
+        convertValueToLiteral(decoratorArgs),
+        ts.createIdentifier('arguments'),
+      ]);
+  }
+}

scripts/build/transformers/plugin-class.ts

@@ -0,0 +1,71 @@
+import * as ts from 'typescript';
+
+import { Logger } from '../../logger';
+import { convertValueToLiteral, getDecorator, getDecoratorArgs, getDecoratorName } from '../helpers';
+import { transformMembers } from './members';
+
+function transformClass(cls: any, ngcBuild?: boolean) {
+  Logger.profile('transformClass: ' + cls.name.text);
+
+  const pluginStatics = [];
+  const dec: any = getDecorator(cls);
+
+  if (dec) {
+    const pluginDecoratorArgs = getDecoratorArgs(dec);
+
+    // add plugin decorator args as static properties of the plugin's class
+    for (const prop in pluginDecoratorArgs) {
+      pluginStatics.push(
+        ts.createProperty(
+          undefined,
+          [ts.createToken(ts.SyntaxKind.StaticKeyword)],
+          ts.createIdentifier(prop),
+          undefined,
+          undefined,
+          convertValueToLiteral(pluginDecoratorArgs[prop])
+        )
+      );
+    }
+  }
+
+  cls = ts.createClassDeclaration(
+    ngcBuild && cls.decorators && cls.decorators.length
+      ? cls.decorators.filter(d => getDecoratorName(d) === 'Injectable')
+      : undefined, // remove Plugin and Injectable decorators
+    [ts.createToken(ts.SyntaxKind.ExportKeyword)],
+    cls.name,
+    cls.typeParameters,
+    cls.heritageClauses,
+    [...transformMembers(cls), ...pluginStatics]
+  );
+
+  Logger.profile('transformClass: ' + cls.name.text);
+  return cls;
+}
+
+function transformClasses(file: ts.SourceFile, ctx: ts.TransformationContext, ngcBuild?: boolean) {
+  Logger.silly('Transforming file: ' + file.fileName);
+  return ts.visitEachChild(
+    file,
+    node => {
+      if (
+        node.kind !== ts.SyntaxKind.ClassDeclaration ||
+        (node.modifiers && node.modifiers.find(v => v.kind === ts.SyntaxKind.DeclareKeyword))
+      ) {
+        return node;
+      }
+      return transformClass(node, ngcBuild);
+    },
+    ctx
+  );
+}
+
+export function pluginClassTransformer(ngcBuild?: boolean): ts.TransformerFactory<ts.SourceFile> {
+  return (ctx: ts.TransformationContext) => {
+    return tsSourceFile => {
+      if (tsSourceFile.fileName.indexOf('src/@ionic-native/plugins') > -1)
+        return transformClasses(tsSourceFile, ctx, ngcBuild);
+      return tsSourceFile;
+    };
+  };
+}

scripts/build/transformers/properties.ts

@@ -0,0 +1,58 @@
+import * as ts from 'typescript';
+
+import { getDecorator, getDecoratorName } from '../helpers';
+
+export function transformProperty(members: any[], index: number) {
+  const property = members[index] as ts.PropertyDeclaration,
+    decorator = getDecorator(property),
+    decoratorName = getDecoratorName(decorator);
+
+  let type: 'cordova' | 'instance';
+
+  switch (decoratorName) {
+    case 'CordovaProperty':
+      type = 'cordova';
+      break;
+
+    case 'InstanceProperty':
+      type = 'instance';
+      break;
+
+    default:
+      return property;
+  }
+
+  const getter = ts.createGetAccessor(
+    undefined,
+    undefined,
+    property.name,
+    undefined,
+    property.type,
+    ts.createBlock([
+      ts.createReturn(
+        ts.createCall(ts.createIdentifier(type + 'PropertyGet'), undefined, [
+          ts.createThis(),
+          ts.createLiteral((property.name as any).text),
+        ])
+      ),
+    ])
+  );
+
+  const setter = ts.createSetAccessor(
+    undefined,
+    undefined,
+    property.name,
+    [ts.createParameter(undefined, undefined, undefined, 'value', undefined, property.type)],
+    ts.createBlock([
+      ts.createStatement(
+        ts.createCall(ts.createIdentifier(type + 'PropertySet'), undefined, [
+          ts.createThis(),
+          ts.createLiteral((property.name as any).text),
+          ts.createIdentifier('value'),
+        ])
+      ),
+    ])
+  );
+
+  return [getter, setter];
+}

scripts/build/transpile.ts

@@ -0,0 +1,40 @@
+import * as ts from 'typescript';
+import { pluginClassTransformer } from './transformers/plugin-class';
+import { importsTransformer } from './transformers/imports';
+import { clone } from 'lodash';
+import { emitInjectableClasses, extractInjectables } from './transformers/extract-injectables';
+import { COMPILER_OPTIONS, PLUGIN_PATHS, TS_CONFIG } from './helpers';
+
+let host: ts.CompilerHost;
+
+export function getCompilerHost() {
+  if (!host) host = ts.createCompilerHost(TS_CONFIG);
+  return host;
+}
+
+export function getProgram(declaration = false, pluginPaths: string[] = PLUGIN_PATHS) {
+  const compilerOptions: ts.CompilerOptions = clone(COMPILER_OPTIONS);
+  compilerOptions.declaration = declaration;
+  compilerOptions.moduleResolution = ts.ModuleResolutionKind.NodeJs;
+  compilerOptions.target = ts.ScriptTarget.ES5;
+  compilerOptions.module = ts.ModuleKind.ES2015;
+  compilerOptions.inlineSourceMap = true;
+  compilerOptions.inlineSources = true;
+  compilerOptions.lib = ['lib.dom.d.ts', 'lib.es5.d.ts', 'lib.es2015.d.ts', 'lib.es2016.d.ts', 'lib.es2017.d.ts'];
+
+  return ts.createProgram(pluginPaths, compilerOptions, getCompilerHost());
+}
+
+export function generateDeclarations(sourceFiles?: string[]) {
+  return getProgram(true, sourceFiles).emit(undefined, getCompilerHost().writeFile, undefined, true);
+}
+
+export function transpile() {
+  const emitResult = getProgram().emit(undefined, getCompilerHost().writeFile, undefined, false, {
+    before: [extractInjectables(), importsTransformer(), pluginClassTransformer()],
+  });
+
+  emitInjectableClasses();
+
+  return emitResult;
+}

scripts/build/tsconfig-plugin.json

@@ -1,22 +0,0 @@
-{
-  "compilerOptions": {
-    "baseUrl": ".",
-    "declaration": true,
-    "stripInternal": true,
-    "experimentalDecorators": true,
-    "emitDecoratorMetadata": true,
-    "module": "es2015",
-    "moduleResolution": "node",
-    "outDir": "../../../dist/@ionic-native/",
-    "paths": {
-      "@ionic-native/core": ["../../../dist/@ionic-native/core"]
-    },
-    "rootDir": "../../../src/@ionic-native/plugins/",
-    "target": "es5",
-    "skipLibCheck": true,
-    "lib": ["es2015", "dom"],
-    "sourceMap": true,
-    "inlineSources": true
-  },
-  "files": []
-}

scripts/docs-json/index.ts

@@ -0,0 +1,112 @@
+import * as fs from 'fs-extra';
+import { basename, dirname, resolve } from 'path';
+import { Application } from 'typedoc';
+import TypeDoc = require('typedoc');
+import { runInNewContext } from 'vm';
+
+interface Plugin {
+  packageName: string;
+  displayName: string;
+  description: string;
+  platforms: string[];
+  usage: string;
+  repo: string;
+  installVariables: string[];
+  cordovaPlugin: {
+    name: string;
+  };
+  premierSlug: string;
+  capacitorIncompatible: boolean;
+}
+
+const rootDir = resolve(__dirname, '../..');
+const typedocTmp = resolve(__dirname, 'typedoc.tmp.json');
+const pluginsDir = resolve(rootDir, 'src/@ionic-native/plugins');
+const typedoc = new Application();
+
+typedoc.options.addReader(new TypeDoc.TSConfigReader());
+typedoc.options.addReader(new TypeDoc.TypeDocReader());
+
+typedoc.bootstrap({
+  mode: 'modules',
+  ignoreCompilerErrors: true,
+});
+
+run(pluginsDir);
+
+async function run(pluginsDir: string) {
+  const typedocData = await generateTypedoc(pluginsDir);
+  const modules = typedocData.children.filter(isModule);
+  const plugins = modules.filter(hasPlugin).map(processPlugin);
+  await fs.outputJson(resolve(__dirname, 'plugins.json'), plugins, {
+    spaces: 2,
+  });
+}
+
+async function generateTypedoc(root: string, outputPath = typedocTmp) {
+  const pluginDirs = await fs.readdir(root);
+  const paths = pluginDirs.map(dir => resolve(root, dir, 'index.ts'));
+  typedoc.generateJson(paths, outputPath);
+  return fs.readJson(outputPath);
+}
+
+function processPlugin(pluginModule): Plugin {
+  const pluginClass = pluginModule.children.find(isPlugin);
+  const decorator = getPluginDecorator(pluginClass);
+  const packageName = `@ionic-native/${basename(dirname(pluginModule.originalName))}`;
+  const displayName = getTag(pluginClass, 'name');
+  const usage = getTag(pluginClass, 'usage');
+  const description = getTag(pluginClass, 'description');
+  const premierSlug = getTag(pluginClass, 'premier');
+  const capIncompat = getTag(pluginClass, 'capacitorincompatible');
+  const capacitorIncompatible = capIncompat ? true : undefined;
+  return {
+    packageName,
+    displayName,
+    description,
+    usage,
+    platforms: decorator.platforms,
+    repo: decorator.repo,
+    installVariables: decorator.installVariables,
+    cordovaPlugin: {
+      name: decorator.plugin,
+    },
+    premierSlug,
+    capacitorIncompatible,
+  };
+}
+
+/**
+ * Typedoc only gives us the Plugin decorator internals
+ * as a string. So, rather than try to parse that with a RegExp,
+ * we evaluate it using Node's vm module.
+ */
+const getPluginDecorator = (child: any) => {
+  if (isPlugin(child)) {
+    const decorator = child.decorators.find(d => d.name === 'Plugin');
+    return runInNewContext(`(${decorator.arguments.config})`);
+  }
+};
+
+const getTag = (child: any, tagName: string): string => {
+  if (hasTags(child)) {
+    const tag = child.comment.tags.find(t => t.tag === tagName);
+    if (tag) {
+      return tag.text;
+    }
+  }
+};
+
+const isModule = (child: any): boolean => child.kind === 1;
+
+const isClass = (child: any): boolean => child.kind === 128;
+
+const isPlugin = (child: any): boolean =>
+  isClass(child) &&
+  hasTags(child) &&
+  Array.isArray(child.decorators) &&
+  child.decorators.some(d => d.name === 'Plugin');
+
+const hasPlugin = (child: any): boolean => child.children.some(isPlugin);
+
+const hasTags = (child: any): boolean => child.comment && Array.isArray(child.comment.tags);

scripts/docs-json/readme.md

@@ -0,0 +1,3 @@
+# docs-json
+
+This script reads and generates [typedoc](https://github.com/TypeStrong/typedoc) data for each of the plugins in `src/@ionic-native/plugins`. That data is then formatted and output as `plugins.json` in this directory.

scripts/docs/config.json

@@ -2,5 +2,5 @@
   "sitePath": "../ionic-site",
   "v2DocsDir": "docs/native",
   "docsDest": "../ionic-site/content/docs/native",
-  "pluginDir": "dist/@ionic-native"
+  "pluginDir": "dist/@ionic-native/plugins"
 }

scripts/docs/configs/tag-defs.js

@@ -1,4 +0,0 @@
-module.exports = function(parseTagsProcessor) {
-  parseTagsProcessor.tagDefinitions = parseTagsProcessor.tagDefinitions
-    .concat(require('../tag-defs/tag-defs'));
-};

scripts/docs/dgeni-config.js

@@ -1,79 +0,0 @@
-"use strict";
-const Package = require('dgeni').Package,
-  jsdocPackage = require('dgeni-packages/jsdoc'),
-  nunjucksPackage = require('dgeni-packages/nunjucks'),
-  typescriptPackage = require('dgeni-packages/typescript'),
-  linksPackage = require('dgeni-packages/links'),
-  path = require('path'),
-  config = require('../config.json');
-
-module.exports = currentVersion => {
-
-  return new Package('ionic-native-docs', [jsdocPackage, nunjucksPackage, typescriptPackage, linksPackage])
-
-    .processor(require('./processors/remove-private-members'))
-    .processor(require('./processors/hide-private-api'))
-    .processor(require('./processors/parse-optional'))
-    .processor(require('./processors/mark-properties'))
-    .processor(require('./processors/npm-id'))
-    .processor(require('./processors/jekyll'))
-
-    .config(require('./configs/log'))
-    .config(require('./configs/template-filters'))
-    .config(require('./configs/template-tags'))
-    .config(require('./configs/tag-defs'))
-    .config(require('./configs/links'))
-
-    .config(function(renderDocsProcessor, computePathsProcessor) {
-
-      currentVersion = {
-        href: '/' + config.v2DocsDir.replace('content/', ''),
-        folder: '',
-        name: currentVersion
-      };
-
-      renderDocsProcessor.extraData.version = {
-        list: [currentVersion],
-        current: currentVersion,
-        latest: currentVersion
-      };
-
-      computePathsProcessor.pathTemplates = [{
-        docTypes: ['class'],
-        getOutputPath: doc => 'content/' + config.v2DocsDir + '/' +  doc.name + '/index.md'
-      }];
-
-    })
-
-    //configure file reading
-    .config(function(readFilesProcessor, readTypeScriptModules) {
-
-      // Don't run unwanted processors since we are not using the normal file reading processor
-      readFilesProcessor.$enabled = false;
-      readFilesProcessor.basePath = path.resolve(__dirname, '../..');
-
-      readTypeScriptModules.basePath = path.resolve(__dirname, '../..');
-      readTypeScriptModules.sourceFiles = [
-        './src/@ionic-native/plugins/**/*.ts'
-      ];
-    })
-
-    // Configure file writing
-    .config(function(writeFilesProcessor) {
-      writeFilesProcessor.outputFolder  = '../ionic-site/';
-    })
-
-    // Configure rendering
-    .config(function(templateFinder) {
-
-      templateFinder.templateFolders.unshift(path.resolve(__dirname, 'templates'));
-
-      // Specify how to match docs to templates.
-      templateFinder.templatePatterns = [
-        '${ doc.template }',
-        '${ doc.docType }.template.html',
-        'common.template.html'
-      ];
-    });
-
-};

scripts/docs/dgeni-readmes-config.js

@@ -1,76 +0,0 @@
-"use strict";
-const Package = require('dgeni').Package,
-  jsdocPackage = require('dgeni-packages/jsdoc'),
-  nunjucksPackage = require('dgeni-packages/nunjucks'),
-  typescriptPackage = require('dgeni-packages/typescript'),
-  linksPackage = require('dgeni-packages/links'),
-  path = require('path'),
-  config = require('../config.json');
-
-module.exports = currentVersion => {
-
-  return new Package('ionic-native-readmes', [jsdocPackage, nunjucksPackage, typescriptPackage, linksPackage])
-
-    .processor(require('./processors/readmes'))
-    .processor(require('./processors/remove-private-members'))
-    .processor(require('./processors/hide-private-api'))
-    .processor(require('./processors/npm-id'))
-
-    .config(require('./configs/log'))
-    .config(require('./configs/template-filters'))
-    .config(require('./configs/template-tags'))
-    .config(require('./configs/tag-defs'))
-    .config(require('./configs/links'))
-
-
-    .config(function(renderDocsProcessor, computePathsProcessor) {
-
-      currentVersion = {
-        href: '/' + config.v2DocsDir.replace('content/', ''),
-        folder: '',
-        name: currentVersion
-      };
-
-      renderDocsProcessor.extraData.version = {
-        list: [currentVersion],
-        current: currentVersion,
-        latest: currentVersion
-      };
-
-      computePathsProcessor.pathTemplates = [{
-        docTypes: ['class'],
-        getOutputPath: doc => doc.originalModule.replace(config.pluginDir + '/', '')
-          .replace('/plugins', '')
-          .replace('/index', '/README.md')
-      }];
-
-    })
-
-    //configure file reading
-    .config(function(readFilesProcessor, readTypeScriptModules) {
-      // Don't run unwanted processors since we are not using the normal file reading processor
-      readFilesProcessor.$enabled = false;
-      readFilesProcessor.basePath = path.resolve(__dirname, '../..');
-
-      readTypeScriptModules.basePath = path.resolve(path.resolve(__dirname, '../..'));
-      readTypeScriptModules.sourceFiles = ['./src/@ionic-native/plugins/**/*.ts'];
-    })
-
-    // Configure file writing
-    .config(function(writeFilesProcessor) {
-      writeFilesProcessor.outputFolder  = './dist/';
-    })
-
-    // Configure rendering
-    .config(function(templateFinder) {
-      templateFinder.templateFolders.unshift(path.resolve(__dirname, 'templates'));
-
-      // Specify how to match docs to templates.
-      templateFinder.templatePatterns = [
-        '${ doc.template }',
-        '${ doc.docType }.template.md',
-        'readme.template.md'
-      ];
-    });
-
-};

scripts/docs/dgeni/configs/links.js

@@ -1,3 +1,3 @@
-module.exports = function(getLinkInfo) {
+module.exports = function (getLinkInfo) {
   getLinkInfo.useFirstAmbiguousLink = false;
 };

scripts/docs/dgeni/configs/log.js

@@ -1,3 +1,3 @@
-module.exports = function(log) {
+module.exports = function (log) {
   log.level = 'error'; //'silly', 'debug', 'info', 'warn', 'error'
 };

scripts/docs/dgeni/configs/tag-defs.js

@@ -0,0 +1,3 @@
+module.exports = function (parseTagsProcessor) {
+  parseTagsProcessor.tagDefinitions = parseTagsProcessor.tagDefinitions.concat(require('../tag-defs/tag-defs'));
+};

scripts/docs/dgeni/configs/template-filters.js

@@ -1,4 +1,4 @@
-module.exports = function(templateEngine) {
+module.exports = function (templateEngine) {
   // Nunjucks and Angular conflict in their template bindings so change the Nunjucks
   // Also conflict with Jekyll
   templateEngine.config.tags = {
@@ -7,6 +7,6 @@ module.exports = function(templateEngine) {
     blockStart: '<@',
     blockEnd: '@>',
     commentStart: '<#',
-    commentEnd: '#>'
+    commentEnd: '#>',
   };
 };

scripts/docs/dgeni/configs/template-tags.js

@@ -1,4 +1,4 @@
-module.exports = function(templateEngine) {
+module.exports = function (templateEngine) {
   // add custom filters to nunjucks
   templateEngine.filters.push(
     require('../filters/capital'),

scripts/docs/dgeni/dgeni-config.js

@@ -0,0 +1,75 @@
+'use strict';
+const Package = require('dgeni').Package,
+  jsdocPackage = require('dgeni-packages/jsdoc'),
+  nunjucksPackage = require('dgeni-packages/nunjucks'),
+  typescriptPackage = require('dgeni-packages/typescript'),
+  linksPackage = require('dgeni-packages/links'),
+  path = require('path'),
+  config = require('../config.json');
+
+module.exports = currentVersion => {
+  return (
+    new Package('ionic-native-docs', [jsdocPackage, nunjucksPackage, typescriptPackage, linksPackage])
+
+      .processor(require('./processors/remove-private-members'))
+      .processor(require('./processors/hide-private-api'))
+      .processor(require('./processors/parse-optional'))
+      .processor(require('./processors/mark-properties'))
+      .processor(require('./processors/npm-id'))
+      .processor(require('./processors/jekyll'))
+
+      .config(require('./configs/log'))
+      .config(require('./configs/template-filters'))
+      .config(require('./configs/template-tags'))
+      .config(require('./configs/tag-defs'))
+      .config(require('./configs/links'))
+
+      .config(function (renderDocsProcessor, computePathsProcessor) {
+        currentVersion = {
+          href: '/' + config.v2DocsDir.replace('content/', ''),
+          folder: '',
+          name: currentVersion,
+        };
+
+        renderDocsProcessor.extraData.version = {
+          list: [currentVersion],
+          current: currentVersion,
+          latest: currentVersion,
+        };
+
+        computePathsProcessor.pathTemplates = [
+          {
+            docTypes: ['class'],
+            getOutputPath: doc => 'content/' + config.v2DocsDir + '/' + doc.name + '/index.md',
+          },
+        ];
+      })
+
+      //configure file reading
+      .config(function (readFilesProcessor, readTypeScriptModules) {
+        // Don't run unwanted processors since we are not using the normal file reading processor
+        readFilesProcessor.$enabled = false;
+        readFilesProcessor.basePath = path.resolve(__dirname, '../../..');
+
+        readTypeScriptModules.basePath = path.resolve(__dirname, '../../..');
+        readTypeScriptModules.sourceFiles = ['./src/@ionic-native/plugins/**/*.ts'];
+      })
+
+      // Configure file writing
+      .config(function (writeFilesProcessor) {
+        writeFilesProcessor.outputFolder = '../ionic-site/';
+      })
+
+      // Configure rendering
+      .config(function (templateFinder) {
+        templateFinder.templateFolders.unshift(path.resolve(__dirname, 'templates'));
+
+        // Specify how to match docs to templates.
+        templateFinder.templatePatterns = [
+          '${ doc.template }',
+          '${ doc.docType }.template.html',
+          'common.template.html',
+        ];
+      })
+  );
+};

scripts/docs/dgeni/dgeni-readmes-config.js

@@ -0,0 +1,70 @@
+'use strict';
+const Package = require('dgeni').Package,
+  jsdocPackage = require('dgeni-packages/jsdoc'),
+  nunjucksPackage = require('dgeni-packages/nunjucks'),
+  typescriptPackage = require('dgeni-packages/typescript'),
+  linksPackage = require('dgeni-packages/links'),
+  path = require('path'),
+  config = require('../config.json');
+
+module.exports = currentVersion => {
+  return (
+    new Package('ionic-native-readmes', [jsdocPackage, nunjucksPackage, typescriptPackage, linksPackage])
+
+      .processor(require('./processors/readmes'))
+      .processor(require('./processors/remove-private-members'))
+      .processor(require('./processors/hide-private-api'))
+      .processor(require('./processors/npm-id'))
+
+      .config(require('./configs/log'))
+      .config(require('./configs/template-filters'))
+      .config(require('./configs/template-tags'))
+      .config(require('./configs/tag-defs'))
+      .config(require('./configs/links'))
+
+      .config(function (renderDocsProcessor, computePathsProcessor) {
+        currentVersion = {
+          href: '/' + config.v2DocsDir.replace('content/', ''),
+          folder: '',
+          name: currentVersion,
+        };
+
+        renderDocsProcessor.extraData.version = {
+          list: [currentVersion],
+          current: currentVersion,
+          latest: currentVersion,
+        };
+
+        computePathsProcessor.pathTemplates = [
+          {
+            docTypes: ['class'],
+            getOutputPath: doc =>
+              doc.originalModule.replace(config.pluginDir + '/', '').replace(/\/index$/, '/README.md'),
+          },
+        ];
+      })
+
+      //configure file reading
+      .config(function (readFilesProcessor, readTypeScriptModules) {
+        // Don't run unwanted processors since we are not using the normal file reading processor
+        readFilesProcessor.$enabled = false;
+        readFilesProcessor.basePath = path.resolve(__dirname, '../../..');
+
+        readTypeScriptModules.basePath = path.resolve(path.resolve(__dirname, '../../..'));
+        readTypeScriptModules.sourceFiles = ['./src/@ionic-native/plugins/**/*.ts'];
+      })
+
+      // Configure file writing
+      .config(function (writeFilesProcessor) {
+        writeFilesProcessor.outputFolder = './dist/@ionic-native/';
+      })
+
+      // Configure rendering
+      .config(function (templateFinder) {
+        templateFinder.templateFolders.unshift(path.resolve(__dirname, 'templates'));
+
+        // Specify how to match docs to templates.
+        templateFinder.templatePatterns = ['${ doc.template }', '${ doc.docType }.template.md', 'readme.template.md'];
+      })
+  );
+};

scripts/docs/dgeni/filters/capital.js

@@ -0,0 +1,5 @@
+'use strict';
+module.exports = {
+  name: 'capital',
+  process: str => (str ? str.charAt(0).toUpperCase() + str.substring(1) : ''),
+};

scripts/docs/dgeni/filters/code.js

@@ -1,4 +1,4 @@
-"use strict";
+'use strict';
 const encoder = new require('node-html-encoder').Encoder();
 
 function code(str, inline, lang) {
@@ -20,5 +20,5 @@ function code(str, inline, lang) {
 
 module.exports = {
   name: 'code',
-  process: (str, lang) => code(str, true, lang)
+  process: (str, lang) => code(str, true, lang),
 };

scripts/docs/dgeni/filters/dashify.js

@@ -0,0 +1,5 @@
+'use strict';
+module.exports = {
+  name: 'dashify',
+  process: str => (str ? str.replace(/\s/g, '-') : ''),
+};

scripts/docs/dgeni/filters/dump.js

@@ -0,0 +1,5 @@
+'use strict';
+module.exports = {
+  name: 'dump',
+  process: obj => console.log(obj),
+};

scripts/docs/dgeni/processors/debug.js

@@ -0,0 +1,39 @@
+'use strict';
+module.exports = function test() {
+  return {
+    name: 'debug',
+    $runBefore: ['rendering-docs'],
+    $process: function (docs) {
+      docs.forEach(function (doc) {
+        if (doc.name == 'Camera') {
+          console.log(doc.tags);
+          doc.tags.forEach(function (tag) {
+            if (tag.tagName == 'classes') {
+            }
+          });
+
+          doc.moduleDoc.exports.forEach(function (d, i) {
+            if (d.name === 'CameraOptions') {
+              console.log('Name: ' + d.name);
+              console.log('Type: ' + d.docType);
+              console.log('First member: ', d.members[0]);
+            }
+          });
+
+          var exports = doc.exportSymbol.parent.exports;
+          for (var p in exports) {
+            if (p == 'CameraOptions') {
+              var x = exports[p];
+              console.log(x.members.quality);
+            }
+          }
+          doc.members.forEach(function (method) {
+            if (method.name === 'getPicture') {
+              console.log(method);
+            }
+          });
+        }
+      });
+    },
+  };
+};

scripts/docs/dgeni/processors/hide-private-api.js

@@ -1,9 +1,9 @@
-"use strict";
+'use strict';
 module.exports = function removePrivateApi() {
   return {
     name: 'remove-private-api',
     description: 'Prevent the private apis from being rendered',
     $runBefore: ['rendering-docs'],
-    $process: docs => docs.filter(doc => !doc.private && (!doc.tags || !doc.tags.tagsByName.get('hidden')))
+    $process: docs => docs.filter(doc => !doc.private && (!doc.tags || !doc.tags.tagsByName.get('hidden'))),
   };
 };

scripts/docs/dgeni/processors/jekyll.js

@@ -0,0 +1,63 @@
+'use strict';
+module.exports = function jekyll(renderDocsProcessor) {
+  return {
+    name: 'jekyll',
+    description: 'Create jekyll includes',
+    $runAfter: ['paths-computed'],
+    $runBefore: ['rendering-docs'],
+    $process: docs => {
+      // pretty up and sort the docs object for menu generation
+      docs = docs.filter(doc => (!!doc.name && !!doc.outputPath) || doc.docType === 'index-page');
+
+      docs.push({
+        docType: 'class',
+        URL: 'https://github.com/ionic-team/ionic-native-google-maps/blob/master/documents/README.md',
+        name: 'Google Maps',
+      });
+
+      docs.sort((a, b) => {
+        const textA = a.name ? a.name.toUpperCase() : '',
+          textB = b.name ? b.name.toUpperCase() : '';
+
+        return textA < textB ? -1 : textA > textB ? 1 : 0;
+      });
+
+      docs.forEach(doc => {
+        if (!doc.outputPath) {
+          return;
+        }
+
+        doc.outputPath = doc.outputPath.toLowerCase().replace(/\s/g, '-');
+        doc.URL = doc.outputPath.replace('docs//', 'docs/').replace('/index.md', '').replace('content/', '');
+        // add trailing slash to plugin pages
+        if (!doc.URL.endsWith('/') && !doc.URL.endsWith('.html')) {
+          doc.URL = doc.URL + '/';
+        }
+
+        doc.URL = '/' + doc.URL;
+      });
+
+      const betaDocs = [];
+
+      docs = docs.filter(doc => {
+        if (doc.beta === true) {
+          betaDocs.push(doc);
+          return false;
+        }
+        return true;
+      });
+
+      docs = docs.concat(betaDocs);
+
+      // add side menu
+      docs.push({
+        docType: 'nativeMenu',
+        id: 'native_menu',
+        template: 'native_menu.template.html',
+        outputPath: 'content/_includes/fluid/native_menu.html',
+      });
+
+      return docs;
+    },
+  };
+};

scripts/docs/dgeni/processors/mark-properties.js

@@ -0,0 +1,16 @@
+'use strict';
+module.exports = function markProperties() {
+  return {
+    name: 'mark-properties',
+    $runBefore: ['rendering-docs'],
+    $process: docs =>
+      docs.map(doc => {
+        for (let i in doc.members) {
+          if (doc.members.hasOwnProperty(i) && typeof doc.members[i].parameters === 'undefined') {
+            doc.members[i].isProperty = true;
+          }
+        }
+        return doc;
+      }),
+  };
+};

scripts/docs/dgeni/processors/npm-id.js

@@ -1,4 +1,4 @@
-"use strict";
+'use strict';
 module.exports = function npmId(renderDocsProcessor) {
   return {
     name: 'npm-id',
@@ -6,7 +6,7 @@ module.exports = function npmId(renderDocsProcessor) {
     $runBefore: ['rendering-docs'],
     $process: docs => {
       // pretty up and sort the docs object for menu generation
-      docs = docs.filter(function(doc) {
+      docs = docs.filter(function (doc) {
         return (!!doc.name && !!doc.outputPath) || doc.docType === 'index-page';
       });
 
@@ -15,6 +15,6 @@ module.exports = function npmId(renderDocsProcessor) {
       });
 
       return docs;
-    }
+    },
   };
 };

scripts/docs/dgeni/processors/parse-optional.js

@@ -1,4 +1,4 @@
-"use strict";
+'use strict';
 module.exports = function parseOptional() {
   return {
     $runBefore: ['rendering-docs'],
@@ -17,6 +17,6 @@ module.exports = function parseOptional() {
         }
       });
       return docs;
-    }
-  }
+    },
+  };
 };

scripts/docs/dgeni/processors/readmes.js

@@ -1,4 +1,4 @@
-"use strict";
+'use strict';
 module.exports = function readmes(renderDocsProcessor) {
   return {
     name: 'readmes',
@@ -10,10 +10,10 @@ module.exports = function readmes(renderDocsProcessor) {
       docs = docs.filter(doc => (!!doc.name && !!doc.outputPath) || doc.docType === 'index-page');
 
       docs.forEach(doc => {
-        doc.outputPath = doc.outputPath.replace('src/', '');
+        doc.outputPath = doc.outputPath.replace('src/@ionic-native/', '');
       });
 
       return docs;
-    }
+    },
   };
 };

scripts/docs/dgeni/processors/remove-private-members.js

@@ -1,4 +1,4 @@
-"use strict";
+'use strict';
 module.exports = function removePrivateMembers() {
   return {
     name: 'remove-private-members',
@@ -7,7 +7,6 @@ module.exports = function removePrivateMembers() {
     $runBefore: ['rendering-docs'],
     $process: docs => {
       docs.forEach(doc => {
-
         if (doc.members) {
           doc.members = doc.members.filter(member => !member.tags.tagsByName.get('hidden'));
         }
@@ -15,10 +14,9 @@ module.exports = function removePrivateMembers() {
         if (doc.statics) {
           doc.statics = doc.statics.filter(staticMethod => !staticMethod.tags.tagsByName.get('hidden'));
         }
-
       });
 
       return docs;
-    }
+    },
   };
 };

scripts/docs/dgeni/tag-defs/tag-defs.js

@@ -0,0 +1,11 @@
+'use strict';
+module.exports = [
+  { name: 'advanced' },
+  { name: 'demo' },
+  { name: 'beta', transforms: (doc, tag, value) => typeof value !== 'undefined' }, // make the value true or undefined instead of '' or undefined
+  { name: 'usage' },
+  { name: 'hidden' }, // hide from docs
+  { name: 'classes' }, // related classes
+  { name: 'interfaces' }, // related interfaces
+  { name: 'paid', transforms: (doc, tag, value) => typeof value !== 'undefined' }, // paid plugin, set value to true
+];

scripts/docs/dgeni/templates/common.template.html

@@ -0,0 +1,208 @@
+---
+layout: "fluid/docs_base"
+version: "<$ version.current.name $>"
+versionHref: "<$ version.current.href.replace('content/','') $>"
+path: "<$ doc.path $>"
+category: native
+id: "<$ doc.name|lower|replace(' ','-') $>"
+title: "<@ if doc.docType == "directive" @><$ doc.name | dashCase $><@ else @><$ doc.name $><@ endif @>"
+header_sub_title: "<$ doc.docType | capital $> in module <$ doc.module $>"
+doc: "<$ doc.name $>"
+docType: "<$ doc.docType $>"
+---
+
+<@- macro interfaceTable(interface) -@> <@ for export in doc.moduleDoc.exports -@> <@ if export.name == interface @>
+<table class="table param-table" style="margin: 0;">
+  <thead>
+    <tr>
+      <th>Param</th>
+      <th>Type</th>
+      <th>Details</th>
+    </tr>
+  </thead>
+  <tbody>
+    <@ for param in export.members @>
+    <tr>
+      <td>
+        <$ param.name $>
+      </td>
+      <td>
+        <code><$ param.returnType | escape $></code>
+      </td>
+      <td>
+        <$ param.description | marked $> <@ if param.optional @><em>(optional)</em><@ endif @>
+      </td>
+    </tr>
+    <@ endfor @>
+  </tbody>
+</table>
+<@ endif @> <@- endfor @> <@- endmacro -@> <@- macro githubViewLink(doc) -@>
+<a
+  href="https://github.com/ionic-team/ionic-native/tree/master/<$ doc.fileInfo.relativePath $>#L<$ doc.location.start.line+1 $>-L<$ doc.location.end.line+1 $>"
+  ><$ doc.fileInfo.relativePath $> (line <$ doc.location.start.line+1 $>)</a
+>
+<@- endmacro -@> <@- macro paramTable(params, isDirective) -@>
+<table class="table param-table" style="margin: 0;">
+  <thead>
+    <tr>
+      <th><@ if isDirective @>Attr<@ else @>Param<@ endif @></th>
+      <th>Type</th>
+      <th>Details</th>
+    </tr>
+  </thead>
+  <tbody>
+    <@- for param in params @>
+    <tr>
+      <td>
+        <$ param.name $> <@- if param.alias @>| <$ param.alias $><@ endif -@>
+      </td>
+      <td>
+        <$ typeList(param.typeList) $>
+      </td>
+      <td>
+        <$ param.description | marked $> <@- if param.defaultValue @>
+        <p><em>(default: <$ param.defaultValue $>)</em></p>
+        <@ endif -@>
+      </td>
+    </tr>
+    <@ endfor -@>
+  </tbody>
+</table>
+<@- endmacro -@> <@- macro functionSyntax(fn) @> <@- set sep = joiner(',&nbsp;') -@>
+<code
+  ><$ fn.name $><@- if not fn.isProperty @>(<@ endif -@><@- for param in fn.params @><$ sep() $> <@- if
+  param.type.optional @>[<@- endif -@> <$ param.name $> <@- if param.type.optional -@>]<@- endif -@> <@- endfor -@><@-
+  if not fn.isProperty @>)<@- endif -@></code
+>
+<@- endmacro -@> <@- macro typeList(types) -@> <@ set separator = joiner("|") @> <@- for type in types @><$ separator()
+$><$ type | code $><@ endfor -@> <@- endmacro -@> <@- macro typeInfo(fn) -@> <$ typeList(fn.typeList) $> <$
+fn.description $> <@- endmacro -@> <@- macro documentPlatforms(method) -@> <@- if method.decorators @> <@ for prop in
+method.decorators[0].argumentInfo @> <@ if prop.platforms @>
+<p>
+  <strong>Platforms:</strong>
+  <@- for platform in prop.platforms -@>
+  <strong class="tag"><$ platform $></strong>&nbsp; <@- endfor -@>
+</p>
+<@ endif @> <@ endfor @> <@- endif @> <@- endmacro -@> <@ macro documentMethod(method) -@>
+<h3><a class="anchor" name="<$ method.name $>" href="#<$ method.name $>"></a><$ functionSyntax(method) $></h3>
+<$ documentPlatforms(method) $> <$ method.description $> <@ if method.params -@> <$ paramTable(method.params) $> <@-
+endif @> <@ if method.returns -@>
+<div class="return-value" markdown="1">
+  <i class="icon ion-arrow-return-left"></i>
+  <b>Returns:</b> <$ typeInfo(method.returns) $>
+</div>
+<@- endif @> <@- endmacro -@> <@- macro documentClass(doc) @> <@- if doc.statics.length -@>
+<h2><a class="anchor" name="static-members" href="#static-members"></a>Static Members</h2>
+<@ for method in doc.statics -@> <$ documentMethod(method) $> <@ endfor -@> <@ endif @> <# --- methods in class --- #>
+<@- if doc.members and doc.members.length @>
+
+<h2><a class="anchor" name="instance-members" href="#instance-members"></a>Instance Members</h2>
+<@ for method in doc.members -@> <$ documentMethod(method) $> <@- endfor @> <@- endif -@> <@ endmacro @>
+
+<h1 class="api-title">
+  <$ doc.name $> <@- if doc.beta == true -@>
+  <span class="beta" title="beta">&beta;</span>
+  <@- endif -@> <@- if doc.paid == true -@>
+  <span class="paid" title="paid">Paid</span>
+  <@- endif -@>
+</h1>
+
+<a
+  class="improve-v2-docs"
+  href="http://github.com/ionic-team/ionic-native/edit/master/<$ doc.fileInfo.relativePath|replace('/home/ubuntu/ionic-native/', '')|replace('//','/') $>#L<$ doc.location.start.line $>"
+>
+  Improve this doc
+</a>
+
+<# --- Decorators --- #> <@- if doc.decorators @> <@ for prop in doc.decorators[0].argumentInfo @> <@ if doc.beta ==
+true @>
+<p class="beta-notice">
+  This plugin is still in beta stage and may not work as expected. Please submit any issues to the
+  <a target="_blank" href="<$ prop.repo $>/issues">plugin repo</a>.
+</p>
+<@ endif @> <@ if doc.paid == true @>
+<p class="paid-notice">
+  This plugin might require a paid license, or might take a share of your app's earnings. Check the
+  <a target="_blank" rel="nofollow" href="<$ prop.repo $>">plugin's repo</a> for more information.
+</p>
+<@ endif @> <# --- Plugin description --- #> <$ doc.description | marked $>
+
+<p>
+  Repo:
+  <a href="<$ prop.repo $>">
+    <$ prop.repo $>
+  </a>
+</p>
+
+<# --- Install commands --- #>
+<h2><a class="anchor" name="installation" href="#installation"></a>Installation</h2>
+<ol class="installation">
+  <li>
+    Install the Cordova and Ionic Native plugins:<br />
+    <pre><code class="nohighlight">$ <@ if prop.install @><$ prop.install | replace('<', '&lt;').replace('>', '&gt;') $><@ else @>ionic cordova plugin add <$ prop.plugin $><@ endif @>
+$ npm install @ionic-native/<$ doc.npmId $>
+</code></pre>
+  </li>
+  <li>
+    <a href="https://ionicframework.com/docs/native/#Add_Plugins_to_Your_App_Module"
+      >Add this plugin to your app's module</a
+    >
+  </li>
+</ol>
+
+<# --- Plugin supported platforms --- #> <@ if prop.platforms @>
+<h2><a class="anchor" name="platforms" href="#platforms"></a>Supported platforms</h2>
+<ul>
+  <@ for platform in prop.platforms -@>
+  <li><$ platform $></li>
+  <@- endfor @>
+</ul>
+<@ endif @> <@ endfor @> <@ endif -@> <# --- end of: if doc.decorators --- #> <# --- Plugin usage --- #> <@ if doc.usage
+@>
+<h2><a class="anchor" name="usage" href="#usage"></a>Usage</h2>
+<$ doc.usage | marked $> <@ endif @> <# --- Plugin attributes --- #> <@- if doc.properties -@>
+<h2><a class="anchor" name="attributes" href="#attributes"></a>Attributes:</h2>
+<table class="table" style="margin: 0;">
+  <thead>
+    <tr>
+      <th>Attribute</th>
+      <@ set hasTypes = false @> <@ for prop in doc.properties @> <@ if prop.type @> <@ set hasTypes = true @> <@ endif
+      @> <@ endfor @> <@ if hasTypes @>
+      <th>Type</th>
+      <@ endif @>
+      <th>Description</th>
+    </tr>
+  </thead>
+  <tbody>
+    <@- for prop in doc.properties -@>
+    <tr>
+      <td>
+        <$ prop.name $>
+      </td>
+      <@ if hasTypes @>
+      <td>
+        <$ prop.type.name $>
+      </td>
+      <@ endif @>
+      <td>
+        <$ prop.description $>
+      </td>
+    </tr>
+    <@ endfor -@>
+  </tbody>
+</table>
+<@- endif -@> <# --- Plugin class documentation --- #> <$ documentClass(doc) $> <# --- Advanced usage --- #> <@- if
+doc.advanced -@>
+<h2><a class="anchor" name="advanced" href="#advanced"></a>Advanced</h2>
+<$ doc.advanced | marked $> <@- endif -@> <# --- Other classes --- #> <@- for tag in doc.tags.tags -@> <@- if
+tag.tagName == 'classes' -@> <@- set classes = tag.description.split('\n') -@> <@- for item in classes -@> <@- if
+item.length > 1 -@> <@- for export in doc.moduleDoc.exports -@> <@- if export.name == item -@>
+<h2><a class="anchor" name="<$ item $>" href="#<$ item $>"></a><$ item $></h2>
+<$ documentClass(export) $> <@- endif -@> <@- endfor -@> <@- endif -@> <@- endfor -@> <@- endif -@> <@- endfor -@> <#
+--- Other interfaces --- #> <@ for tag in doc.tags.tags -@> <@ if tag.tagName == 'interfaces' @> <@ set interfaces =
+tag.description.split('\n') @> <@ for item in interfaces -@> <@ if item.length > 1 @>
+<h2><a class="anchor" name="<$ item $>" href="#<$ item $>"></a><$ item $></h2>
+<$ interfaceTable(item) $> <@ endif @> <@- endfor @> <@ endif @> <@- endfor @> <# --- Related links --- #> <@- if
+doc.see @>
+<h2><a class="anchor" name="related" href="#related"></a>Related</h2>
+<@ for s in doc.see @> <$ s | safe $> <@- endfor -@> <@- endif -@>

scripts/docs/dgeni/templates/native_menu.template.html

@@ -0,0 +1,14 @@
+<li class="capitalize {% if page.id == 'overview' %}active{% endif %}">
+  <a href="/docs/native/">Overview</a>
+</li>
+<li class="capitalize {% if page.id == 'mocking' %}active{% endif %}">
+  <a href="/docs/native/browser.html">Browser Usage</a>
+</li>
+<@- for doc in docs @><@ if doc.URL and doc.private != true @>
+<li class="capitalize {% if page.id == '<$ doc.name|lower|dashify $>' %}active{% endif %}">
+  <a href="<$ doc.URL $>"
+    ><$ doc.name $><@ if doc.paid == true @> <span class="paid">Paid</span><@ endif @><@ if doc.beta == true @>
+    <span class="beta">&beta;</span><@ endif @></a
+  >
+</li>
+<@ endif @><@ endfor @>

scripts/docs/dgeni/templates/readme.template.md

@@ -1,10 +1,11 @@
-<a style="float:right;font-size:12px;" href="http://github.com/driftyco/ionic-native/edit/master/<$ doc.fileInfo.relativePath|replace('/home/ubuntu/ionic-native/', '')|replace('//','/') $>#L<$ doc.location.start.line $>">
+<a style="float:right;font-size:12px;" href="http://github.com/ionic-team/ionic-native/edit/master/<$ doc.fileInfo.relativePath|replace('/home/ubuntu/ionic-native/', '')|replace('//','/') $>#L<$ doc.location.start.line $>">
   Improve this doc
 </a>
 
 # <$ doc.name $>
 
 <@- if doc.beta == true @>
+
   <p style="color:orange">
     This plugin is still in beta stage and may not work as expected. Please
     submit any issues to the <a target="_blank"
@@ -12,12 +13,11 @@
   </p>
 <@ endif -@>
 
-
 <@ for prop in doc.decorators[0].argumentInfo @>
 
 ```
-$ <@ if prop.install @><$ prop.install $><@ else @>ionic plugin add <$ prop.plugin $><@ endif @>
-$ npm install --save @ionic-native/<$ doc.npmId $>
+$ <@ if prop.install @><$ prop.install $><@ else @>ionic cordova plugin add <$ prop.plugin $><@ endif @>
+$ npm install @ionic-native/<$ doc.npmId $>
 ```
 
 ## [Usage Documentation](https://ionicframework.com/docs/native/<$ doc.fileInfo.relativePath|replace('/home/ubuntu/ionic-native/', '')|replace('//','/')|replace('index.ts','')|replace('src/@ionic-native/plugins/','') $>)
@@ -29,9 +29,11 @@ Plugin Repo: [<$ prop.repo $>](<$ prop.repo $>)
 <@- if prop.platforms @>
 
 ## Supported platforms
+
 <@ for platform in prop.platforms -@>
+
 - <$ platform $>
-<@ endfor @>
+  <@ endfor @>
 
 <@ endif -@>
 

scripts/docs/filters/capital.js

@@ -1,5 +0,0 @@
-"use strict";
-module.exports = {
-  name: 'capital',
-  process: str => str? str.charAt(0).toUpperCase() + str.substring(1) : ''
-};

scripts/docs/filters/dashify.js

@@ -1,5 +0,0 @@
-"use strict";
-module.exports = {
-  name: 'dashify',
-  process: str => str? str.replace(/\s/g, '-') : ''
-};

scripts/docs/filters/dump.js

@@ -1,5 +0,0 @@
-"use strict";
-module.exports = {
-  name: 'dump',
-  process: obj => console.log(obj)
-};

scripts/docs/gulp-tasks.js

@@ -1,39 +1,34 @@
-"use strict";
-const config = require('../config.json'),
+'use strict';
+const config = require('./config.json'),
   projectPackage = require('../../package.json'),
   path = require('path'),
-  fs = require('fs-extra-promise').useFs(require('fs-extra')),
+  fs = require('fs-extra'),
   Dgeni = require('dgeni');
 
 module.exports = gulp => {
-  gulp.task('docs', [], () => {
-
+  gulp.task('docs', () => {
     try {
-
-      const ionicPackage = require('./dgeni-config')(projectPackage.version),
+      const ionicPackage = require('./dgeni/dgeni-config')(projectPackage.version),
         dgeni = new Dgeni([ionicPackage]);
 
       return dgeni.generate().then(docs => console.log(docs.length + ' docs generated'));
-
     } catch (err) {
       console.log(err.stack);
     }
-
   });
 
-  gulp.task('readmes', [], function() {
-
-    fs.copySync(path.resolve(__dirname, '..', '..', 'README.md'), path.resolve(__dirname, '..', '..', config.pluginDir, 'core', 'README.md'));
+  gulp.task('readmes', () => {
+    fs.copySync(
+      path.resolve(__dirname, '..', '..', 'README.md'),
+      path.resolve(__dirname, '..', '..', config.pluginDir, 'core', 'README.md')
+    );
 
     try {
-
-      const ionicPackage = require('./dgeni-readmes-config')(projectPackage.version),
+      const ionicPackage = require('./dgeni/dgeni-readmes-config')(projectPackage.version),
         dgeni = new Dgeni([ionicPackage]);
       return dgeni.generate().then(docs => console.log(docs.length + ' README files generated'));
-
     } catch (err) {
       console.log(err.stack);
     }
-
   });
 };

scripts/docs/prepare.sh

@@ -34,4 +34,4 @@ function run {
 
 }
 
-source $(dirname $0)/../utils.inc.sh
+source $(dirname $0)/utils.inc.sh

scripts/docs/processors/debug.js

@@ -1,43 +0,0 @@
-"use strict";
-module.exports = function test(){
-  return {
-    name: 'debug',
-    $runBefore: ['rendering-docs'],
-    $process: function(docs){
-      docs.forEach(function(doc){
-        if (doc.name == "Camera"){
-
-          console.log(doc.tags);
-          doc.tags.forEach(function(tag){
-            if(tag.tagName == 'classes'){
-
-            }
-          });
-
-          doc.moduleDoc.exports.forEach(function(d,i){
-            if(d.name === 'CameraOptions') {
-              console.log('Name: ' + d.name);
-              console.log('Type: ' + d.docType);
-              console.log('First member: ', d.members[0]);
-            }
-          });
-
-
-          var exports = doc.exportSymbol.parent.exports;
-          for(var p in exports) {
-            if(p == 'CameraOptions')
-            {
-              var x = exports[p];
-              console.log(x.members.quality);
-            }
-          }
-          doc.members.forEach(function(method){
-            if (method.name === "getPicture") {
-              console.log(method);
-            }
-          })
-        }
-      })
-    }
-  }
-}

scripts/docs/processors/jekyll.js

@@ -1,38 +0,0 @@
-"use strict";
-module.exports = function jekyll(renderDocsProcessor) {
-  return {
-    name: 'jekyll',
-    description: 'Create jekyll includes',
-    $runAfter: ['paths-computed'],
-    $runBefore: ['rendering-docs'],
-    $process: docs => {
-
-      // pretty up and sort the docs object for menu generation
-      docs = docs.filter(doc => (!!doc.name && !!doc.outputPath) || doc.docType === 'index-page');
-
-      docs.sort((a, b) => {
-        const textA = a.name ? a.name.toUpperCase() : '',
-          textB = b.name ? b.name.toUpperCase() : '';
-
-        return (textA < textB) ? -1 : (textA > textB) ? 1 : 0;
-      });
-
-      docs.forEach(doc => {
-        doc.outputPath = doc.outputPath.toLowerCase().replace(/\s/g, '-');
-        doc.URL = doc.outputPath.replace('docs//', 'docs/')
-          .replace('/index.md', '')
-          .replace('content/', '');
-      });
-
-      // add side menu
-      docs.push({
-        docType: 'nativeMenu',
-        id: 'native_menu',
-        template: 'native_menu.template.html',
-        outputPath: 'content/_includes/fluid/native_menu.html'
-      });
-
-      return docs;
-    }
-  };
-};

scripts/docs/processors/mark-properties.js

@@ -1,15 +0,0 @@
-"use strict";
-module.exports = function markProperties() {
-  return {
-    name: 'mark-properties',
-    $runBefore: ['rendering-docs'],
-    $process: docs => docs.map(doc => {
-      for (let i in doc.members) {
-        if (doc.members.hasOwnProperty(i) && typeof doc.members[i].parameters === 'undefined') {
-          doc.members[i].isProperty = true;
-        }
-      }
-      return doc;
-    })
-  }
-};

scripts/docs/tag-defs/tag-defs.js

@@ -1,10 +0,0 @@
-"use strict";
-module.exports = [
-  {'name': 'advanced'},
-  {'name': 'demo'},
-  {'name': 'beta', transforms: (doc, tag, value) => typeof value !== 'undefined'}, // make the value true or undefined instead of '' or undefined
-  {'name': 'usage'},
-  {'name': 'hidden'}, // hide from docs
-  {'name': 'classes'}, // related classes
-  {'name': 'interfaces'} // related interfaces
-];

scripts/docs/templates/common.template.html

@@ -1,283 +0,0 @@
----
-layout: "fluid/docs_base"
-version: "<$ version.current.name $>"
-versionHref: "<$ version.current.href.replace('content/','') $>"
-path: "<$ doc.path $>"
-category: native
-id: "<$ doc.name|lower|replace(' ','-') $>"
-title: "<@ if doc.docType == "directive" @><$ doc.name | dashCase $><@ else @><$ doc.name $><@ endif @>"
-header_sub_title: "<$ doc.docType | capital $> in module <$ doc.module $>"
-doc: "<$ doc.name $>"
-docType: "<$ doc.docType $>"
----
-
-<@- macro interfaceTable(interface) -@>
-<@ for export in doc.moduleDoc.exports -@>
-<@ if export.name == interface @>
-<table class="table param-table" style="margin:0;">
-  <thead>
-  <tr>
-    <th>Param</th>
-    <th>Type</th>
-    <th>Details</th>
-  </tr>
-  </thead>
-  <tbody>
-  <@ for param in export.members @>
-  <tr>
-    <td>
-      <$ param.name $>
-    </td>
-    <td>
-      <code><$ param.returnType | escape $></code>
-    </td>
-    <td>
-      <$ param.description | marked $>
-      <@ if param.optional @><em>(optional)</em><@ endif @>
-    </td>
-  </tr>
-  <@ endfor @>
-  </tbody>
-</table>
-<@ endif @>
-<@- endfor @>
-<@- endmacro -@>
-
-<@- macro githubViewLink(doc) -@>
-<a href="https://github.com/driftyco/ionic-native/tree/master/<$ doc.fileInfo.relativePath $>#L<$ doc.location.start.line+1 $>-L<$ doc.location.end.line+1 $>"><$ doc.fileInfo.relativePath $> (line <$ doc.location.start.line+1 $>)</a>
-<@- endmacro -@>
-
-<@- macro paramTable(params, isDirective) -@>
-<table class="table param-table" style="margin:0;">
-  <thead>
-  <tr>
-    <th><@ if isDirective @>Attr<@ else @>Param<@ endif @></th>
-    <th>Type</th>
-    <th>Details</th>
-  </tr>
-  </thead>
-  <tbody>
-  <@- for param in params @>
-  <tr>
-    <td>
-      <$ param.name $>
-      <@- if param.alias @>| <$ param.alias $><@ endif -@>
-    </td>
-    <td>
-      <$ typeList(param.typeList) $>
-    </td>
-    <td>
-      <$ param.description | marked $>
-      <@- if param.defaultValue @><p><em>(default: <$ param.defaultValue $>)</em></p><@ endif -@>
-    </td>
-  </tr>
-  <@ endfor -@>
-  </tbody>
-</table>
-<@- endmacro -@>
-
-<@- macro functionSyntax(fn) @>
-  <@- set sep = joiner(',&nbsp;') -@>
-  <code><$ fn.name $><@- if not fn.isProperty @>(<@ endif -@><@- for param in fn.params @><$ sep() $>
-  <@- if param.type.optional @>[<@- endif -@>
-  <$ param.name $>
-  <@- if param.type.optional -@>]<@- endif -@>
-  <@- endfor -@><@- if not fn.isProperty @>)<@- endif -@></code>
-<@- endmacro -@>
-
-<@- macro typeList(types) -@>
-<@ set separator = joiner("|") @>
-<@- for type in types @><$ separator() $><$ type | code $><@ endfor -@>
-<@- endmacro -@>
-
-<@- macro typeInfo(fn) -@>
-<$ typeList(fn.typeList) $> <$ fn.description $>
-<@- endmacro -@>
-
-<@- macro documentPlatforms(method) -@>
-<@- if method.decorators @>
-<@ for prop in method.decorators[0].argumentInfo @>
-<@ if prop.platforms @>
-<p>
-  <strong>Platforms:</strong>
-  <@- for platform in prop.platforms -@>
-  <strong class="tag"><$ platform $></strong>&nbsp;
-  <@- endfor -@>
-</p>
-<@ endif @>
-<@ endfor @>
-<@- endif @>
-<@- endmacro -@>
-
-<@ macro documentMethod(method) -@>
-<h3><a class="anchor" name="<$ method.name $>" href="#<$ method.name $>"></a><$ functionSyntax(method) $></h3>
-<$ documentPlatforms(method) $>
-<$ method.description $>
-<@ if method.params -@>
-<$ paramTable(method.params) $>
-<@- endif @>
-
-<@ if method.returns -@>
-<div class="return-value" markdown="1">
-  <i class="icon ion-arrow-return-left"></i>
-  <b>Returns:</b> <$ typeInfo(method.returns) $>
-</div>
-<@- endif @>
-<@- endmacro -@>
-
-<@- macro documentClass(doc) @>
-<@- if doc.statics.length -@>
-<h2>Static Members</h2>
-<@ for method in doc.statics -@>
-<$ documentMethod(method) $>
-<@ endfor -@>
-<@ endif @>
-
-<# --- methods in class --- #>
-<@- if doc.members and doc.members.length @>
-
-<h2>Instance Members</h2>
-<@ for method in doc.members -@>
-<$ documentMethod(method) $>
-<@- endfor @>
-<@- endif -@>
-<@ endmacro @>
-
-<h1 class="api-title"><$ doc.name $>
-  <@- if doc.beta == true -@>
-    <span class="beta" title="beta">&beta;</span>
-  <@- endif -@>
-</h1>
-
-<a class="improve-v2-docs" href="http://github.com/driftyco/ionic-native/edit/master/<$ doc.fileInfo.relativePath|replace('/home/ubuntu/ionic-native/', '')|replace('//','/') $>#L<$ doc.location.start.line $>">
-  Improve this doc
-</a>
-
-<# --- Decorators --- #>
-<@- if doc.decorators @>
-<@ for prop in doc.decorators[0].argumentInfo @>
-<@ if doc.beta == true @>
-<p class="beta-notice">
-  This plugin is still in beta stage and may not work as expected. Please
-  submit any issues to the <a target="_blank"
-  href="<$ prop.repo $>/issues">plugin repo</a>.
-</p>
-<@ endif @>
-
-<# --- Install commands --- #>
-<pre><code class="nohighlight">$ <@ if prop.install @><$ prop.install $><@ else @>ionic plugin add --save <$ prop.plugin $><@ endif @>
-$ npm install --save @ionic-native/<$ doc.npmId $>
-</code></pre>
-<p>Repo:
-  <a href="<$ prop.repo $>">
-    <$ prop.repo $>
-  </a>
-</p>
-
-<# --- Plugin description --- #>
-<$ doc.description | marked $>
-
-<# --- Plugin supported platforms --- #>
-<@ if prop.platforms @>
-<h2>Supported platforms</h2>
-<ul>
-  <@ for platform in prop.platforms -@>
-  <li><$ platform $></li>
-  <@- endfor @>
-</ul>
-<@ endif @>
-<@ endfor @>
-<@ endif -@> <# --- end of: if doc.decorators --- #>
-
-<# --- Plugin usage --- #>
-<@ if doc.usage @>
-<h2>Usage</h2>
-<$ doc.usage | marked $>
-<@ endif @>
-
-<# --- Plugin attributes --- #>
-<@- if doc.properties -@>
-<h2>Attributes:</h2>
-<table class="table" style="margin:0;">
-  <thead>
-  <tr>
-    <th>Attribute</th>
-    <@ set hasTypes = false @>
-    <@ for prop in doc.properties @>
-    <@ if prop.type @>
-    <@ set hasTypes = true @>
-    <@ endif @>
-    <@ endfor @>
-    <@ if hasTypes @>
-    <th>Type</th>
-    <@ endif @>
-    <th>Description</th>
-  </tr>
-  </thead>
-  <tbody>
-  <@- for prop in doc.properties -@>
-  <tr>
-    <td>
-      <$ prop.name $>
-    </td>
-    <@ if hasTypes @>
-    <td>
-      <$ prop.type.name $>
-    </td>
-    <@ endif @>
-    <td>
-      <$ prop.description $>
-    </td>
-  </tr>
-  <@ endfor -@>
-  </tbody>
-</table>
-<@- endif -@>
-
-<# --- Plugin class documentation --- #>
-<$ documentClass(doc) $>
-
-<# --- Advanced usage --- #>
-<@- if doc.advanced -@>
-<h2><a class="anchor" name="advanced" href="#advanced"></a>Advanced</h2>
-<$ doc.advanced | marked $>
-<@- endif -@>
-
-<# --- Other classes --- #>
-<@- for tag in doc.tags.tags -@>
-<@- if tag.tagName == 'classes' -@>
-<@- set classes = tag.description.split('\n') -@>
-<@- for item in classes -@>
-<@- if item.length > 1 -@>
-<@- for export in doc.moduleDoc.exports -@>
-<@- if export.name == item -@>
-<h2><a class="anchor" name="<$ item $>" href="#<$ item $>"></a><$ item $></h2>
-<$ documentClass(export) $>
-<@- endif -@>
-<@- endfor -@>
-<@- endif -@>
-<@- endfor -@>
-<@- endif -@>
-<@- endfor -@>
-
-<# --- Other interfaces --- #>
-<@ for tag in doc.tags.tags -@>
-<@ if tag.tagName == 'interfaces' @>
-<@ set interfaces = tag.description.split('\n') @>
-<@ for item in interfaces -@>
-<@ if item.length > 1 @>
-<h2><a class="anchor" name="<$ item $>" href="#<$ item $>"></a><$ item $></h2>
-<$ interfaceTable(item) $>
-<@ endif @>
-<@- endfor @>
-<@ endif @>
-<@- endfor @>
-
-
-<# --- Related links --- #>
-<@- if doc.see @>
-<h2><a class="anchor" name="related" href="#related"></a>Related</h2>
-<@ for s in doc.see @>
-<$ s | safe $>
-<@- endfor -@>
-<@- endif -@>

scripts/docs/templates/native_menu.template.html

@@ -1,14 +0,0 @@
-<li class="capitalize {% if page.id == 'overview' %}active{% endif %}">
-  <a href="/docs/native/">Overview</a>
-</li>
-<li class="capitalize {% if page.id == 'mocking' %}active{% endif %}">
-  <a href="/docs/native/browser.html">Browser Usage</a>
-</li>
-<@- for doc in docs @><@ if doc.URL and doc.private != true and doc.beta != true @>
-<li class="capitalize {% if page.id == '<$ doc.name|lower|dashify $>' %}active{% endif %}">
-  <a href="/<$ doc.URL $>"><$ doc.name $></a>
-</li><@ endif @><@ endfor @>
-<@- for doc in docs @><@ if doc.URL and doc.private != true and doc.beta == true @>
-<li class="capitalize {% if page.id == '<$ doc.name|lower|dashify $>' %}active{% endif %}">
-  <a href="/<$ doc.URL $>"><$ doc.name $> <span class="beta">&beta;</span></a>
-</li><@ endif @><@ endfor @>

scripts/docs/update_docs.sh

@@ -31,11 +31,11 @@ function run {
   if [ $CHANGED -eq 0 ];
   then
     echo "-- No changes detected for the following commit, docs not updated."
-    echo "https://github.com/driftyco/$CIRCLE_PROJECT_REPONAME/commit/$CIRCLE_SHA1"
+    echo "https://github.com/ionic-team/$GITHUB_PROJECT_REPONAME/commit/$GITHUB_SHA1"
   else
     git config --global user.email "hi@ionicframework.com"
     git config --global user.name "Ionitron"
-    git commit -am "Automated build of native docs driftyco/$CIRCLE_PROJECT_REPONAME@$CIRCLE_SHA1"
+    git commit -am "Automated build of native docs ionic-team/$GITHUB_PROJECT_REPONAME@$GITHUB_SHA1"
     # in case a different commit was pushed to ionic-site during doc/demo gen,
     # try to rebase around it before pushing
     git fetch
@@ -47,4 +47,4 @@ function run {
   fi
 }
 
-source $(dirname $0)/../utils.inc.sh
+source $(dirname $0)/utils.inc.sh

scripts/docs/update_readmes.sh

@@ -18,12 +18,12 @@ function run {
   if [ -z "$CHANGED" ];
   then
     echo "-- No changes detected for the following commit, docs not updated."
-    echo "https://github.com/driftyco/$CIRCLE_PROJECT_REPONAME/commit/$CIRCLE_SHA1"
+    echo "https://github.com/ionic-team/$CIRCLE_PROJECT_REPONAME/commit/$CIRCLE_SHA1"
   else
     git config --global user.email "hi@ionicframework.com"
     git config --global user.name "Ionitron"
     git add -A
-    git commit -am "Automated build of native readmes for driftyco/$CIRCLE_PROJECT_REPONAME@$CIRCLE_SHA1"
+    git commit -am "Automated build of native readmes for ionic-team/$CIRCLE_PROJECT_REPONAME@$CIRCLE_SHA1"
     # in case a different commit was pushed to ionic-site during doc/demo gen,
     # try to rebase around it before pushing
     git fetch
@@ -31,7 +31,7 @@ function run {
 
     # git push origin master || :
 
-    echo "-- Updated docs for $VERSION_NAME succesfully!"
+    echo "-- Updated docs for $VERSION_NAME successfully!"
   fi
 }
 

scripts/docs/utils.inc.sh

@@ -1,5 +1,4 @@
 # bash utils from angularjs
-
 # This file provides:
 # - a default control flow
 #   * initializes the environment
@@ -36,7 +35,6 @@
 # Special arguments that are always available:
 # - "--action=.*": This parameter will be used to dispatch to a function with that name when the
 #   script is started
-
 # - "--verbose=true": This will set the `-x` flag in bash so that all calls will be logged
 #
 # Utility functions:
@@ -46,7 +44,6 @@
 # - getVar
 # - serVar
 # - isFunction
-
 # always stop on errors
 set -e
 

scripts/git/clone.sh

@@ -21,7 +21,7 @@ function run {
   git config --global user.email "hi@ionicframework.com"
   git config --global user.name "Ionitron"
 
-  git clone git@github.com:driftyco/$REPOSITORY.git $DIRECTORY $ARGS
+  git clone git@github.com:ionic-team/$REPOSITORY.git $DIRECTORY $ARGS
   cd $DIRECTORY
   git fetch origin --tags
   cd ../

scripts/git/config.sh

@@ -0,0 +1,2 @@
+git config --global user.email "hi@ionicframework.com"
+git config --global user.name "Ionitron"

scripts/logger.ts

@@ -0,0 +1,11 @@
+import { createLogger, format, transports } from 'winston';
+
+const { combine, colorize, simple } = format;
+
+const LOG_LEVEL = 'verbose';
+
+export const Logger = createLogger({
+  level: LOG_LEVEL,
+  format: combine(colorize(), simple()),
+  transports: [new transports.Console({ level: LOG_LEVEL })],
+});

scripts/tasks/build-es5.ts

@@ -0,0 +1,90 @@
+import * as fs from 'fs-extra';
+import * as path from 'path';
+import * as uglifyJsPlugin from 'uglifyjs-webpack-plugin';
+import * as unminifiedPlugin from 'unminified-webpack-plugin';
+import * as webpack from 'webpack';
+
+import { ROOT } from '../build/helpers';
+import { cleanEmittedData, EMIT_PATH, InjectableClassEntry } from '../build/transformers/extract-injectables';
+import { Logger } from '../logger';
+
+const DIST = path.resolve(ROOT, 'dist');
+const INDEX_PATH = path.resolve(DIST, 'index.js');
+const INJECTABLE_CLASSES = fs.readJSONSync(EMIT_PATH).map((item: InjectableClassEntry) => {
+  item.file =
+    './' +
+    item.file
+      .split(/[\/\\]+/)
+      .slice(-4, -1)
+      .join('/');
+  return item;
+});
+
+const webpackConfig: webpack.Configuration = {
+  mode: 'production',
+  entry: INDEX_PATH,
+  devtool: 'source-map',
+  target: 'web',
+  output: {
+    path: DIST,
+    filename: 'ionic-native.min.js',
+  },
+  resolve: {
+    modules: ['node_modules'],
+    extensions: ['.js'],
+    alias: {
+      '@ionic-native/core': path.resolve(DIST, '@ionic-native/core/index.js'),
+    },
+  },
+  module: {
+    rules: [
+      {
+        test: /\.js$/,
+        use: path.resolve(ROOT, 'scripts/build/remove-tslib-helpers.js'),
+      },
+    ],
+  },
+  plugins: [
+    new webpack.ProvidePlugin({
+      __extends: ['tslib', '__extends'],
+    }),
+    new webpack.DefinePlugin({
+      'process.env.NODE_ENV': JSON.stringify('production'),
+    }),
+    new uglifyJsPlugin({
+      sourceMap: true,
+    }),
+    new unminifiedPlugin(),
+  ],
+};
+
+function getPluginImport(entry: InjectableClassEntry) {
+  return `import { ${entry.className} } from '${entry.file}';`;
+}
+
+function createIndexFile() {
+  let fileContent = '';
+  fileContent += INJECTABLE_CLASSES.map(getPluginImport).join('\n');
+  fileContent += `\nwindow.IonicNative = {\n`;
+  fileContent += INJECTABLE_CLASSES.map(e => e.className).join(',\n');
+  fileContent += '\n};\n';
+  fileContent += `require('./@ionic-native/core/bootstrap').checkReady();\n`;
+  fileContent += `require('./@ionic-native/core/ng1').initAngular1(window.IonicNative);`;
+
+  fs.writeFileSync(INDEX_PATH, fileContent, { encoding: 'utf-8' });
+}
+
+function compile() {
+  Logger.profile('build-es5');
+  webpack(webpackConfig, (err, stats) => {
+    Logger.profile('build-es5');
+    if (err) Logger.error('Error occurred while compiling with Webpack', err);
+    else {
+      Logger.info('Compiled ES5 file with Webpack successfully.');
+    }
+    cleanEmittedData();
+  });
+}
+
+createIndexFile();
+compile();

scripts/tasks/build-esm.ts

@@ -0,0 +1,37 @@
+import * as fs from 'fs-extra';
+import * as path from 'path';
+
+import { PLUGIN_PATHS, ROOT } from '../build/helpers';
+import { EMIT_PATH } from '../build/transformers/extract-injectables';
+import { generateDeclarations, transpile } from '../build/transpile';
+
+generateDeclarations();
+transpile();
+
+const outDirs = PLUGIN_PATHS.map(p =>
+  p.replace(path.join(ROOT, 'src'), path.join(ROOT, 'dist')).replace(/[\\/]index.ts/, '')
+);
+const injectableClasses = fs.readJSONSync(EMIT_PATH);
+
+outDirs.forEach(dir => {
+  const classes = injectableClasses.filter(entry => entry.dirName === dir.split(/[\\/]+/).pop());
+
+  let jsFile: string = fs.readFileSync(path.join(dir, 'index.js'), 'utf-8'),
+    dtsFile: string = fs.readFileSync(path.join(dir, 'index.d.ts'), 'utf-8');
+
+  classes.forEach(entry => {
+    dtsFile = dtsFile.replace(`class ${entry.className} `, 'class ' + entry.className + 'Original ');
+    dtsFile += `\nexport declare const ${entry.className}: ${entry.className}Original;`;
+    jsFile = jsFile.replace(
+      new RegExp(`([\\s\\(])${entry.className}([\\s\\.;\\(,])`, 'g'),
+      '$1' + entry.className + 'Original$2'
+    );
+    jsFile = jsFile.replace(
+      `export { ${entry.className}Original }`,
+      `var ${entry.className} = new ${entry.className}Original();\nexport { ${entry.className} }`
+    );
+  });
+
+  fs.writeFileSync(path.join(dir, 'index.js'), jsFile, 'utf-8');
+  fs.writeFileSync(path.join(dir, 'index.d.ts'), dtsFile, 'utf-8');
+});

scripts/tasks/build-ngx.ts

@@ -0,0 +1,15 @@
+import {
+  cleanupNgx,
+  generateLegacyBundles,
+  generateDeclarationFiles,
+  modifyMetadata,
+  transpileNgx,
+  transpileNgxCore,
+} from '../build/ngx';
+
+transpileNgxCore();
+transpileNgx();
+generateLegacyBundles();
+generateDeclarationFiles();
+modifyMetadata();
+cleanupNgx();

scripts/tasks/publish.ts

@@ -0,0 +1,112 @@
+import * as Queue from 'async-promise-queue';
+import { exec } from 'child_process';
+import * as fs from 'fs-extra';
+import { merge } from 'lodash';
+import { cpus } from 'os';
+import * as path from 'path';
+
+import { PLUGIN_PATHS, ROOT } from '../build/helpers';
+import { Logger } from '../logger';
+
+// tslint:disable-next-line:no-var-requires
+const MAIN_PACKAGE_JSON = require('../../package.json');
+const VERSION = MAIN_PACKAGE_JSON.version;
+const FLAGS = '--access public';
+
+const PACKAGE_JSON_BASE = {
+  description: 'Ionic Native - Native plugins for ionic apps',
+  main: 'bundle.js',
+  module: 'index.js',
+  typings: 'index.d.ts',
+  author: 'ionic',
+  license: 'MIT',
+  repository: {
+    type: 'git',
+    url: 'https://github.com/ionic-team/ionic-native.git',
+  },
+};
+
+const DIST = path.resolve(ROOT, 'dist/@ionic-native');
+
+const PACKAGES = [];
+
+const MIN_CORE_VERSION = '^5.1.0';
+const RXJS_VERSION = '^5.5.0 || ^6.5.0';
+
+const PLUGIN_PEER_DEPENDENCIES = {
+  '@ionic-native/core': MIN_CORE_VERSION,
+  rxjs: RXJS_VERSION,
+};
+
+function getPackageJsonContent(name: string, peerDependencies = {}, dependencies = {}) {
+  return merge(PACKAGE_JSON_BASE, {
+    name: '@ionic-native/' + name,
+    dependencies,
+    peerDependencies,
+    version: VERSION,
+  });
+}
+
+function writePackageJson(data: any, dir: string) {
+  const filePath = path.resolve(dir, 'package.json');
+  fs.writeJSONSync(filePath, data);
+  PACKAGES.push(dir);
+}
+function writeNGXPackageJson(data: any, dir: string) {
+  const filePath = path.resolve(dir, 'package.json');
+  fs.writeJSONSync(filePath, data);
+}
+function prepare() {
+  // write @ionic-native/core package.json
+  writePackageJson(
+    getPackageJsonContent('core', { rxjs: RXJS_VERSION }, { '@types/cordova': 'latest' }),
+    path.resolve(DIST, 'core')
+  );
+
+  // write plugin package.json files
+  PLUGIN_PATHS.forEach((pluginPath: string) => {
+    const pluginName = pluginPath.split(/[\/\\]+/).slice(-2)[0];
+    const packageJsonContents = getPackageJsonContent(pluginName, PLUGIN_PEER_DEPENDENCIES);
+    const dir = path.resolve(DIST, 'plugins', pluginName);
+    const ngxDir = path.join(dir, 'ngx');
+    writePackageJson(packageJsonContents, dir);
+    writeNGXPackageJson(packageJsonContents, ngxDir);
+  });
+}
+
+async function publish(ignoreErrors = false) {
+  Logger.profile('Publishing');
+  // upload 1 package per CPU thread at a time
+  const worker = Queue.async.asyncify(
+    (pkg: any) =>
+      new Promise<string | void>((resolve, reject) => {
+        exec(`npm publish ${pkg} ${FLAGS}`, (err, stdout) => {
+          if (stdout) {
+            Logger.verbose(stdout.trim());
+            resolve(stdout);
+          }
+          if (err) {
+            if (!ignoreErrors) {
+              if (err.message.includes('You cannot publish over the previously published version')) {
+                Logger.verbose('Ignoring duplicate version error.');
+                return resolve();
+              }
+              reject(err);
+            }
+          }
+        });
+      })
+  );
+
+  try {
+    await Queue(worker, PACKAGES, cpus().length);
+    Logger.info('Done publishing!');
+  } catch (e) {
+    Logger.error('Error publishing!');
+    Logger.error(e);
+  }
+  Logger.profile('Publishing');
+}
+
+prepare();
+publish();

scripts/templates/wrap-min.tmpl

@@ -1,30 +1,60 @@
-import { Plugin, IonicNativePlugin } from '@ionic-native/core';
+/**
+ * This is a template for new plugin wrappers
+ *
+ * TODO:
+ * - Add/Change information below
+ * - Document usage (importing, executing main functionality)
+ * - Remove any imports that you are not using
+ * - Remove all the comments included in this template, EXCEPT the @Plugin wrapper docs and any other docs you added
+ * - Remove this note
+ *
+ */
 import { Injectable } from '@angular/core';
+import { Plugin, Cordova, CordovaProperty, CordovaInstance, InstanceProperty, IonicNativePlugin } from '@ionic-native/core';
+import { Observable } from 'rxjs';
 
 /**
- * @name $Plugin_Name
+ * @name {{ Plugin_Name }}
  * @description
+ * This plugin does something
  *
  * @usage
- * ```
- * import { $PluginName } from 'ionic-native';
+ * ```typescript
+ * import { {{ PluginName }} } from '@ionic-native/{{ plugin-name }}';
  *
  *
- * constructor(private $pluginName: $PluginName) { }
+ * constructor(private {{ pluginName }}: {{ PluginName }}) { }
  *
  * ...
  *
  *
+ * this.{{ pluginName }}.functionName('Hello', 123)
+ *   .then((res: any) => console.log(res))
+ *   .catch((error: any) => console.error(error));
+ *
  * ```
  */
 @Plugin({
-  pluginName: '$PluginName',
-  plugin: '',
-  pluginRef: '',
-  repo: '',
-  platforms: []
+  pluginName: '{{ PluginName }}',
+  plugin: '', // npm package name, example: cordova-plugin-camera
+  pluginRef: '', // the variable reference to call the plugin, example: navigator.geolocation
+  repo: '', // the github repository URL for the plugin
+  install: '', // OPTIONAL install command, in case the plugin requires variables
+  installVariables: [], // OPTIONAL the plugin requires variables
+  platforms: [] // Array of platforms supported, example: ['Android', 'iOS']
 })
 @Injectable()
-export class $PluginName extends IonicNativePlugin {
+export class {{ PluginName }} extends IonicNativePlugin {
+
+  /**
+   * This function does something
+   * @param arg1 {string} Some param to configure something
+   * @param arg2 {number} Another param to configure something
+   * @return {Promise<any>} Returns a promise that resolves when something happens
+   */
+  @Cordova()
+  functionName(arg1: string, arg2: number): Promise<any> {
+    return; // We add return; here to avoid any IDE / Compiler errors
+  }
 
 }

scripts/templates/wrap.tmpl

@@ -5,46 +5,46 @@
  * - Add/Change information below
  * - Document usage (importing, executing main functionality)
  * - Remove any imports that you are not using
- * - Add this file to /src/index.ts (follow style of other plugins)
  * - Remove all the comments included in this template, EXCEPT the @Plugin wrapper docs and any other docs you added
  * - Remove this note
  *
  */
 import { Injectable } from '@angular/core';
 import { Plugin, Cordova, CordovaProperty, CordovaInstance, InstanceProperty, IonicNativePlugin } from '@ionic-native/core';
-import { Observable } from 'rxjs/Observable';
+import { Observable } from 'rxjs';
 
 /**
- * @name $Plugin_Name
+ * @name {{ Plugin_Name }}
  * @description
  * This plugin does something
  *
  * @usage
- * ```
- * import { $PluginName } from '@ionic-native/';
+ * ```typescript
+ * import { {{ PluginName }} } from '@ionic-native/{{ plugin-name }}';
  *
  *
- * constructor(private $pluginName: $PluginName) { }
+ * constructor(private {{ pluginName }}: {{ PluginName }}) { }
  *
  * ...
  *
  *
- * this.$pluginName.functionName('Hello', 123)
+ * this.{{ pluginName }}.functionName('Hello', 123)
  *   .then((res: any) => console.log(res))
  *   .catch((error: any) => console.error(error));
  *
  * ```
  */
 @Plugin({
-  pluginName: '$PluginName',
+  pluginName: '{{ PluginName }}',
   plugin: '', // npm package name, example: cordova-plugin-camera
   pluginRef: '', // the variable reference to call the plugin, example: navigator.geolocation
   repo: '', // the github repository URL for the plugin
-  platforms: [], // Array of platforms supported, example: ['Android', 'iOS']
   install: '', // OPTIONAL install command, in case the plugin requires variables
+  installVariables: [], // OPTIONAL the plugin requires variables
+  platforms: [] // Array of platforms supported, example: ['Android', 'iOS']
 })
 @Injectable()
-export class $PluginName extends IonicNativePlugin {
+export class {{ PluginName }} extends IonicNativePlugin {
 
   /**
    * This function does something

scripts/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "target": "es5",
+    "moduleResolution": "node",
+    "noImplicitAny": false,
+    "lib": ["es6"]
+  },
+  "exclude": ["node_modules"]
+}

src/@ionic-native/core/bootstrap.ts

@@ -1,23 +1,26 @@
-declare var window;
-
 export function checkReady() {
-  const DEVICE_READY_TIMEOUT = 5000;
+  if (typeof process === 'undefined') {
+    const win: any = typeof window !== 'undefined' ? window : {};
+    const DEVICE_READY_TIMEOUT = 5000;
 
-  // To help developers using cordova, we listen for the device ready event and
-  // log an error if it didn't fire in a reasonable amount of time. Generally,
-  // when this happens, developers should remove and reinstall plugins, since
-  // an inconsistent plugin is often the culprit.
-  const before = Date.now();
+    // To help developers using cordova, we listen for the device ready event and
+    // log an error if it didn't fire in a reasonable amount of time. Generally,
+    // when this happens, developers should remove and reinstall plugins, since
+    // an inconsistent plugin is often the culprit.
+    const before = Date.now();
 
-  let didFireReady = false;
-  document.addEventListener('deviceready', () => {
-    console.log(`Ionic Native: deviceready event fired after ${(Date.now() - before)} ms`);
-    didFireReady = true;
-  });
+    let didFireReady = false;
+    win.document.addEventListener('deviceready', () => {
+      console.log(`Ionic Native: deviceready event fired after ${Date.now() - before} ms`);
+      didFireReady = true;
+    });
 
-  setTimeout(() => {
-    if (!didFireReady && window.cordova) {
-      console.warn(`Ionic Native: deviceready did not fire within ${DEVICE_READY_TIMEOUT}ms. This can happen when plugins are in an inconsistent state. Try removing plugins from plugins/ and reinstalling them.`);
-    }
-  }, DEVICE_READY_TIMEOUT);
+    setTimeout(() => {
+      if (!didFireReady && win.cordova) {
+        console.warn(
+          `Ionic Native: deviceready did not fire within ${DEVICE_READY_TIMEOUT}ms. This can happen when plugins are in an inconsistent state. Try removing plugins from plugins/ and reinstalling them.`
+        );
+      }
+    }, DEVICE_READY_TIMEOUT);
+  }
 }

src/@ionic-native/core/decorators.ts

@@ -1,352 +0,0 @@
-import { instanceAvailability, checkAvailability, wrap, wrapInstance, overrideFunction } from './plugin';
-import { getPlugin, getPromise } from './util';
-import { Observable } from 'rxjs/Observable';
-import 'rxjs/observable/throw';
-
-export interface PluginConfig {
-  /**
-   * Plugin name, this should match the class name
-   */
-  pluginName: string;
-  /**
-   * Plugin NPM package name
-   */
-  plugin: string;
-  /**
-   * Plugin object reference
-   */
-  pluginRef?: string;
-  /**
-   * Github repository URL
-   */
-  repo?: string;
-  /**
-   * Custom install command
-   */
-  install?: string;
-  /**
-   * Available installation variables
-   */
-  installVariables?: string[];
-  /**
-   * Supported platforms
-   */
-  platforms?: string[];
-}
-
-export interface CordovaOptions {
-  /**
-   * Set to true if the wrapped method is a sync function
-   */
-  sync?: boolean;
-  /**
-   * Callback order. Set to reverse if the success/error callbacks are the first 2 arguments that the wrapped method takes.
-   */
-  callbackOrder?: 'reverse';
-  /**
-   * Callback style
-   */
-  callbackStyle?: 'node' | 'object';
-  /**
-   * Set a custom index for the success callback function. This doesn't work if callbackOrder or callbackStyle are set.
-   */
-  successIndex?: number;
-  /**
-   * Set a custom index for the error callback function. This doesn't work if callbackOrder or callbackStyle are set.
-   */
-  errorIndex?: number;
-  /**
-   * Success function property name. This must be set if callbackStyle is set to object.
-   */
-  successName?: string;
-  /**
-   * Error function property name. This must be set if callbackStyle is set to object.
-   */
-  errorName?: string;
-  /**
-   * Set to true to return an observable
-   */
-  observable?: boolean;
-  /**
-   * If observable is set to true, this can be set to a different function name that will cancel the observable.
-   */
-  clearFunction?: string;
-  /**
-   * This can be used if clearFunction is set. Set this to true to call the clearFunction with the same arguments used in the initial function.
-   */
-  clearWithArgs?: boolean;
-  /**
-   * Creates an observable that wraps a global event. Replaces document.addEventListener
-   */
-  eventObservable?: boolean;
-  /**
-   * Event name, this must be set if eventObservable is set to true
-   */
-  event?: string;
-  /**
-   * Element to attach the event listener to, this is optional, defaults to `window`
-   */
-  element?: any;
-  /**
-   * Set to true if the wrapped method returns a promise
-   */
-  otherPromise?: boolean;
-  /**
-   * Supported platforms
-   */
-  platforms?: string[];
-}
-
-export interface CordovaCheckOptions {
-  sync?: boolean;
-  observable?: boolean;
-}
-
-export interface CordovaFiniteObservableOptions extends CordovaOptions {
-  /**
-   * Function that gets a result returned from plugin's success callback, and decides whether it is last value and observable should complete.
-   */
-  resultFinalPredicate?: (result: any) => boolean;
-  /**
-   * Function that gets called after resultFinalPredicate, and removes service data that indicates end of stream from the result.
-   */
-  resultTransform?: (result: any) => any;
-}
-
-/**
- * @private
- */
-export function InstanceCheck(opts: CordovaCheckOptions = {}) {
-  return (pluginObj: Object, methodName: string, descriptor: TypedPropertyDescriptor<any>): TypedPropertyDescriptor<any> => {
-    return {
-      value: function(...args: any[]): any {
-        if (instanceAvailability(this)) {
-          return descriptor.value.apply(this, args);
-        } else {
-
-          if (opts.sync) {
-            return;
-          } else if (opts.observable) {
-            return new Observable<any>(() => { });
-          }
-
-          return getPromise(() => { });
-
-        }
-      }
-    };
-  };
-}
-
-/**
- * Executes function only if plugin is available
- * @private
- */
-export function CordovaCheck(opts: CordovaCheckOptions = {}) {
-  return (pluginObj: Object, methodName: string, descriptor: TypedPropertyDescriptor<any>): TypedPropertyDescriptor<any> => {
-    return {
-      value: function(...args: any[]): any {
-        const check = checkAvailability(pluginObj);
-        if (check === true) {
-          return descriptor.value.apply(this, args);
-        } else {
-          if (opts.sync) {
-            return null;
-          } else if (opts.observable) {
-            return Observable.throw(new Error(check && check.error));
-          }
-          return Promise.reject(check && check.error);
-        }
-      }
-    };
-  };
-}
-
-
-/**
- * @private
- *
- * Class decorator specifying Plugin metadata. Required for all plugins.
- *
- * @usage
- * ```typescript
- * @Plugin({
- *  pluginName: 'MyPlugin',
- *  plugin: 'cordova-plugin-myplugin',
- *  pluginRef: 'window.myplugin'
- *  })
- *  export class MyPlugin {
- *
- *    // Plugin wrappers, properties, and functions go here ...
- *
- *  }
- * ```
- */
-export function Plugin(config: PluginConfig) {
-  return function(cls) {
-
-    // Add these fields to the class
-    for (let k in config) {
-      cls[k] = config[k];
-    }
-
-    cls['installed'] = function(printWarning?: boolean) {
-      return !!getPlugin(config.pluginRef);
-    };
-
-    cls['getPlugin'] = function() {
-      return getPlugin(config.pluginRef);
-    };
-
-    cls['checkInstall'] = function() {
-      return checkAvailability(cls) === true;
-    };
-
-    cls['getPluginName'] = function() {
-      return config.pluginName;
-    };
-
-    cls['getPluginRef'] = function() {
-      return config.pluginRef;
-    };
-
-    cls['getPluginInstallName'] = function() {
-      return config.plugin;
-    };
-
-    cls['getPluginRepo'] = function() {
-      return config.repo;
-    };
-
-    cls['getSupportedPlatforms'] = function() {
-      return config.platforms;
-    };
-
-    return cls;
-  };
-}
-
-/**
- * @private
- *
- * Wrap a stub function in a call to a Cordova plugin, checking if both Cordova
- * and the required plugin are installed.
- */
-export function Cordova(opts: CordovaOptions = {}) {
-  return (target: Object, methodName: string, descriptor: TypedPropertyDescriptor<any>) => {
-    return {
-      value: function(...args: any[]) {
-        return wrap(this, methodName, opts).apply(this, args);
-      }
-    };
-  };
-}
-
-/**
- * @private
- *
- * Wrap an instance method
- */
-export function CordovaInstance(opts: any = {}) {
-  return (target: Object, methodName: string) => {
-    return {
-      value: function(...args: any[]) {
-        return wrapInstance(this, methodName, opts).apply(this, args);
-      }
-    };
-  };
-}
-
-/**
- * @private
- *
- *
- * Before calling the original method, ensure Cordova and the plugin are installed.
- */
-export function CordovaProperty(target: any, key: string) {
-  Object.defineProperty(target, key, {
-    enumerable: true,
-    get: () => {
-      if (checkAvailability(target, key) === true) {
-        return getPlugin(target.constructor.getPluginRef())[key];
-      } else {
-        return null;
-      }
-    },
-    set: (value) => {
-      if (checkAvailability(target, key) === true) {
-        getPlugin(target.constructor.getPluginRef())[key] = value;
-      }
-    }
-  });
-}
-
-/**
- * @private
- * @param target
- * @param key
- * @constructor
- */
-export function InstanceProperty(target: any, key: string) {
-  Object.defineProperty(target, key, {
-    enumerable: true,
-    get: function() {
-      return this._objectInstance[key];
-    },
-    set: function(value) {
-      this._objectInstance[key] = value;
-    }
-  });
-}
-
-/**
- * @private
- *
- * Wrap a stub function in a call to a Cordova plugin, checking if both Cordova
- * and the required plugin are installed.
- */
-export function CordovaFunctionOverride(opts: any = {}) {
-  return (target: Object, methodName: string, descriptor: TypedPropertyDescriptor<any>) => {
-    return {
-      value: function(...args: any[]) {
-        return overrideFunction(this, methodName, opts);
-      }
-    };
-  };
-}
-
-
-/**
- * @private
- *
- * Wraps method that returns an observable that can be completed. Provided opts.resultFinalPredicate dictates when the observable completes.
- *
- */
-export function CordovaFiniteObservable(opts: CordovaFiniteObservableOptions = {}) {
-  if (opts.observable === false) {
-    throw new Error('CordovaFiniteObservable decorator can only be used on methods that returns observable. Please provide correct option.');
-  }
-  opts.observable = true;
-  return (target: Object, methodName: string, descriptor: TypedPropertyDescriptor<any>) => {
-    return {
-      value: function(...args: any[]) {
-        let wrappedObservable: Observable<any> = wrap(this, methodName, opts).apply(this, args);
-        return new Observable<any>((observer) => {
-          let wrappedSubscription = wrappedObservable.subscribe({
-            next: (x) => {
-              observer.next(opts.resultTransform ? opts.resultTransform(x) : x);
-              if (opts.resultFinalPredicate && opts.resultFinalPredicate(x)) {
-                observer.complete();
-              }
-            },
-            error: (err) => { observer.error(err); },
-            complete: () => { observer.complete(); }
-          });
-          return () => {
-            wrappedSubscription.unsubscribe();
-          };
-        });
-      }
-    };
-  };
-}

src/@ionic-native/core/decorators/common.spec.ts

@@ -0,0 +1,100 @@
+import { callCordovaPlugin, wrapPromise } from './common';
+
+declare const window: any;
+
+class MockPlugin {
+  static getPluginRef(): string {
+    return 'mockPlugin';
+  }
+
+  static getPluginName(): string {
+    return 'MockPlugin';
+  }
+
+  static getPluginInstallName(): string {
+    return '';
+  }
+
+  create(): MockInstancePluginObject {
+    return new MockInstancePluginObject();
+  }
+}
+
+class MockInstancePluginObject {
+  _pluginInstance: MockCordovaPlugin;
+
+  constructor() {
+    this._pluginInstance = new MockCordovaPlugin();
+  }
+}
+
+class MockCordovaPlugin {
+  static ping = jest.fn((arg: string) => 'pong');
+  static pingAsync = jest.fn((arg: string, success: Function, error: Function) => success('pong'));
+  ping = jest.fn((arg: string) => 'pong');
+  pingAsync = jest.fn((arg: string, success: Function, error: Function) => success('pong'));
+}
+
+describe('Common decorator functions', () => {
+  let plugin: MockPlugin, instancePluginObject: MockInstancePluginObject;
+
+  beforeAll(() => {
+    window.mockPlugin = MockCordovaPlugin;
+    plugin = new MockPlugin();
+    instancePluginObject = plugin.create();
+  });
+
+  describe('callCordovaPlugin', () => {
+    test('should return value from cordova plugin', () => {
+      expect(callCordovaPlugin(plugin, 'ping', ['pingpong'])).toBe('pong');
+    });
+
+    test('original method should have been called', () => {
+      expect(MockCordovaPlugin.ping.mock.calls.length).toBe(1);
+    });
+
+    test('original method should have received args', () => {
+      expect(MockCordovaPlugin.ping.mock.calls[0][0]).toBe('pingpong');
+    });
+  });
+
+  describe('wrapPromise', () => {
+    test('should return a promise that resolves with a value', async () => {
+      expect(await wrapPromise(plugin, 'pingAsync', ['pingpong'])).toBe('pong');
+    });
+
+    test('original method should have been called', () => {
+      expect(MockCordovaPlugin.pingAsync.mock.calls.length).toBe(1);
+    });
+
+    test('original method should have received args', () => {
+      expect(MockCordovaPlugin.pingAsync.mock.calls[0][0]).toBe('pingpong');
+      expect(typeof MockCordovaPlugin.pingAsync.mock.calls[0][1]).toBe('function');
+      expect(typeof MockCordovaPlugin.pingAsync.mock.calls[0][2]).toBe('function');
+    });
+  });
+
+  describe('wrapObservable', () => {
+    test('should return an observable that emits a value', async () => {});
+
+    test('original method should have been called', () => {});
+
+    test('original method should have received args', () => {});
+  });
+
+  describe('wrapEventObservable', () => {
+    test('should return an observable that wraps an event listener', async () => {});
+  });
+
+  describe('callInstance', () => {
+    test('should call an instance method', async () => {});
+
+    test('original method should have been called', () => {
+      // expect(instancePluginObject._pluginInstance.ping.mock.calls.length).toBe(1);
+    });
+
+    test('original method should have received args', () => {
+      // expect(instancePluginObject._pluginInstance.ping.mock.calls[0][0]).toBe('pingpong');
+    });
+  });
+});

src/@ionic-native/core/decorators/common.ts

@@ -0,0 +1,485 @@
+import { fromEvent, Observable } from 'rxjs';
+
+import { CordovaOptions } from './interfaces';
+
+declare const window: any;
+
+export const ERR_CORDOVA_NOT_AVAILABLE = { error: 'cordova_not_available' };
+export const ERR_PLUGIN_NOT_INSTALLED = { error: 'plugin_not_installed' };
+
+export function getPromise<T>(callback: (resolve: Function, reject?: Function) => any): Promise<T> {
+  const tryNativePromise = () => {
+    if (Promise) {
+      return new Promise<T>((resolve, reject) => {
+        callback(resolve, reject);
+      });
+    } else {
+      console.error(
+        'No Promise support or polyfill found. To enable Ionic Native support, please add the es6-promise polyfill before this script, or run with a library like Angular or on a recent browser.'
+      );
+    }
+  };
+
+  if (typeof window !== 'undefined' && window.angular) {
+    const doc = window.document;
+    const injector = window.angular.element(doc.querySelector('[ng-app]') || doc.body).injector();
+    if (injector) {
+      const $q = injector.get('$q');
+      return $q((resolve: Function, reject: Function) => {
+        callback(resolve, reject);
+      });
+    }
+    console.warn(
+      `Angular 1 was detected but $q couldn't be retrieved. This is usually when the app is not bootstrapped on the html or body tag. Falling back to native promises which won't trigger an automatic digest when promises resolve.`
+    );
+  }
+
+  return tryNativePromise();
+}
+
+export function wrapPromise(pluginObj: any, methodName: string, args: any[], opts: CordovaOptions = {}) {
+  let pluginResult: any, rej: Function;
+  const p = getPromise((resolve: Function, reject: Function) => {
+    if (opts.destruct) {
+      pluginResult = callCordovaPlugin(
+        pluginObj,
+        methodName,
+        args,
+        opts,
+        (...args: any[]) => resolve(args),
+        (...args: any[]) => reject(args)
+      );
+    } else {
+      pluginResult = callCordovaPlugin(pluginObj, methodName, args, opts, resolve, reject);
+    }
+    rej = reject;
+  });
+  // Angular throws an error on unhandled rejection, but in this case we have already printed
+  // a warning that Cordova is undefined or the plugin is uninstalled, so there is no reason
+  // to error
+  if (pluginResult && pluginResult.error) {
+    p.catch(() => {});
+    typeof rej === 'function' && rej(pluginResult.error);
+  }
+  return p;
+}
+
+function wrapOtherPromise(pluginObj: any, methodName: string, args: any[], opts: any = {}) {
+  return getPromise((resolve: Function, reject: Function) => {
+    const pluginResult = callCordovaPlugin(pluginObj, methodName, args, opts);
+    if (pluginResult) {
+      if (pluginResult.error) {
+        reject(pluginResult.error);
+      } else if (pluginResult.then) {
+        pluginResult.then(resolve).catch(reject);
+      }
+    } else {
+      reject({ error: 'unexpected_error' });
+    }
+  });
+}
+
+function wrapObservable(pluginObj: any, methodName: string, args: any[], opts: any = {}) {
+  return new Observable(observer => {
+    let pluginResult;
+
+    if (opts.destruct) {
+      pluginResult = callCordovaPlugin(
+        pluginObj,
+        methodName,
+        args,
+        opts,
+        (...args: any[]) => observer.next(args),
+        (...args: any[]) => observer.error(args)
+      );
+    } else {
+      pluginResult = callCordovaPlugin(
+        pluginObj,
+        methodName,
+        args,
+        opts,
+        observer.next.bind(observer),
+        observer.error.bind(observer)
+      );
+    }
+
+    if (pluginResult && pluginResult.error) {
+      observer.error(pluginResult.error);
+      observer.complete();
+    }
+    return () => {
+      try {
+        if (opts.clearFunction) {
+          if (opts.clearWithArgs) {
+            return callCordovaPlugin(
+              pluginObj,
+              opts.clearFunction,
+              args,
+              opts,
+              observer.next.bind(observer),
+              observer.error.bind(observer)
+            );
+          }
+          return callCordovaPlugin(pluginObj, opts.clearFunction, []);
+        }
+      } catch (e) {
+        console.warn(
+          'Unable to clear the previous observable watch for',
+          pluginObj.constructor.getPluginName(),
+          methodName
+        );
+        console.warn(e);
+      }
+    };
+  });
+}
+
+/**
+ * Wrap the event with an observable
+ * @private
+ * @param event event name
+ * @param element The element to attach the event listener to
+ * @returns {Observable}
+ */
+function wrapEventObservable(event: string, element: any): Observable<any> {
+  element =
+    typeof window !== 'undefined' && element
+      ? get(window, element)
+      : element || (typeof window !== 'undefined' ? window : {});
+  return fromEvent(element, event);
+}
+
+/**
+ * Checks if plugin/cordova is available
+ * @return {boolean | { error: string } }
+ * @private
+ */
+export function checkAvailability(
+  pluginRef: string,
+  methodName?: string,
+  pluginName?: string
+): boolean | { error: string };
+export function checkAvailability(
+  pluginObj: any,
+  methodName?: string,
+  pluginName?: string
+): boolean | { error: string };
+export function checkAvailability(plugin: any, methodName?: string, pluginName?: string): boolean | { error: string } {
+  let pluginRef, pluginInstance, pluginPackage;
+
+  if (typeof plugin === 'string') {
+    pluginRef = plugin;
+  } else {
+    pluginRef = plugin.constructor.getPluginRef();
+    pluginName = plugin.constructor.getPluginName();
+    pluginPackage = plugin.constructor.getPluginInstallName();
+  }
+
+  pluginInstance = getPlugin(pluginRef);
+
+  if (!pluginInstance || (!!methodName && typeof pluginInstance[methodName] === 'undefined')) {
+    if (typeof window === 'undefined' || !window.cordova) {
+      cordovaWarn(pluginName, methodName);
+      return ERR_CORDOVA_NOT_AVAILABLE;
+    }
+
+    pluginWarn(pluginName, pluginPackage, methodName);
+    return ERR_PLUGIN_NOT_INSTALLED;
+  }
+
+  return true;
+}
+
+/**
+ * Checks if _objectInstance exists and has the method/property
+ * @private
+ */
+export function instanceAvailability(pluginObj: any, methodName?: string): boolean {
+  return pluginObj._objectInstance && (!methodName || typeof pluginObj._objectInstance[methodName] !== 'undefined');
+}
+
+export function setIndex(args: any[], opts: any = {}, resolve?: Function, reject?: Function): any {
+  // ignore resolve and reject in case sync
+  if (opts.sync) {
+    return args;
+  }
+
+  // If the plugin method expects myMethod(success, err, options)
+  if (opts.callbackOrder === 'reverse') {
+    // Get those arguments in the order [resolve, reject, ...restOfArgs]
+    args.unshift(reject);
+    args.unshift(resolve);
+  } else if (opts.callbackStyle === 'node') {
+    args.push((err: any, result: any) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(result);
+      }
+    });
+  } else if (opts.callbackStyle === 'object' && opts.successName && opts.errorName) {
+    const obj: any = {};
+    obj[opts.successName] = resolve;
+    obj[opts.errorName] = reject;
+    args.push(obj);
+  } else if (typeof opts.successIndex !== 'undefined' || typeof opts.errorIndex !== 'undefined') {
+    const setSuccessIndex = () => {
+      // If we've specified a success/error index
+      if (opts.successIndex > args.length) {
+        args[opts.successIndex] = resolve;
+      } else {
+        args.splice(opts.successIndex, 0, resolve);
+      }
+    };
+
+    const setErrorIndex = () => {
+      // We don't want that the reject cb gets spliced into the position of an optional argument that has not been
+      // defined and thus causing non expected behavior.
+      if (opts.errorIndex > args.length) {
+        args[opts.errorIndex] = reject; // insert the reject fn at the correct specific index
+      } else {
+        args.splice(opts.errorIndex, 0, reject); // otherwise just splice it into the array
+      }
+    };
+
+    if (opts.successIndex > opts.errorIndex) {
+      setErrorIndex();
+      setSuccessIndex();
+    } else {
+      setSuccessIndex();
+      setErrorIndex();
+    }
+  } else {
+    // Otherwise, let's tack them on to the end of the argument list
+    // which is 90% of cases
+    args.push(resolve);
+    args.push(reject);
+  }
+  return args;
+}
+
+export function callCordovaPlugin(
+  pluginObj: any,
+  methodName: string,
+  args: any[],
+  opts: any = {},
+  resolve?: Function,
+  reject?: Function
+) {
+  // Try to figure out where the success/error callbacks need to be bound
+  // to our promise resolve/reject handlers.
+  args = setIndex(args, opts, resolve, reject);
+
+  const availabilityCheck = checkAvailability(pluginObj, methodName);
+
+  if (availabilityCheck === true) {
+    const pluginInstance = getPlugin(pluginObj.constructor.getPluginRef());
+    return pluginInstance[methodName].apply(pluginInstance, args);
+  } else {
+    return availabilityCheck;
+  }
+}
+
+export function callInstance(
+  pluginObj: any,
+  methodName: string,
+  args: any[],
+  opts: any = {},
+  resolve?: Function,
+  reject?: Function
+) {
+  args = setIndex(args, opts, resolve, reject);
+
+  if (instanceAvailability(pluginObj, methodName)) {
+    return pluginObj._objectInstance[methodName].apply(pluginObj._objectInstance, args);
+  }
+}
+
+export function getPlugin(pluginRef: string): any {
+  if (typeof window !== 'undefined') {
+    return get(window, pluginRef);
+  }
+  return null;
+}
+
+export function get(element: Element | Window, path: string) {
+  const paths: string[] = path.split('.');
+  let obj: any = element;
+  for (let i = 0; i < paths.length; i++) {
+    if (!obj) {
+      return null;
+    }
+    obj = obj[paths[i]];
+  }
+  return obj;
+}
+
+export function pluginWarn(pluginName: string, plugin?: string, method?: string): void {
+  if (method) {
+    console.warn(
+      'Native: tried calling ' + pluginName + '.' + method + ', but the ' + pluginName + ' plugin is not installed.'
+    );
+  } else {
+    console.warn(`Native: tried accessing the ${pluginName} plugin but it's not installed.`);
+  }
+  if (plugin) {
+    console.warn(`Install the ${pluginName} plugin: 'ionic cordova plugin add ${plugin}'`);
+  }
+}
+
+/**
+ * @private
+ * @param pluginName
+ * @param method
+ */
+export function cordovaWarn(pluginName: string, method?: string): void {
+  if (typeof process === 'undefined') {
+    if (method) {
+      console.warn(
+        'Native: tried calling ' +
+          pluginName +
+          '.' +
+          method +
+          ', but Cordova is not available. Make sure to include cordova.js or run in a device/simulator'
+      );
+    } else {
+      console.warn(
+        'Native: tried accessing the ' +
+          pluginName +
+          ' plugin but Cordova is not available. Make sure to include cordova.js or run in a device/simulator'
+      );
+    }
+  }
+}
+
+// Fixes a bug in TypeScript 2.9.2 where the ...args is being converted into args: {} and
+// causing compilation issues
+export type WrapFn = (...args: any[]) => any;
+
+/**
+ * @private
+ */
+export const wrap = (pluginObj: any, methodName: string, opts: CordovaOptions = {}): WrapFn => {
+  return (...args: any[]) => {
+    if (opts.sync) {
+      // Sync doesn't wrap the plugin with a promise or observable, it returns the result as-is
+      return callCordovaPlugin(pluginObj, methodName, args, opts);
+    } else if (opts.observable) {
+      return wrapObservable(pluginObj, methodName, args, opts);
+    } else if (opts.eventObservable && opts.event) {
+      return wrapEventObservable(opts.event, opts.element);
+    } else if (opts.otherPromise) {
+      return wrapOtherPromise(pluginObj, methodName, args, opts);
+    } else {
+      return wrapPromise(pluginObj, methodName, args, opts);
+    }
+  };
+};
+
+/**
+ * @private
+ */
+export function wrapInstance(pluginObj: any, methodName: string, opts: any = {}): Function {
+  return (...args: any[]) => {
+    if (opts.sync) {
+      return callInstance(pluginObj, methodName, args, opts);
+    } else if (opts.observable) {
+      return new Observable(observer => {
+        let pluginResult;
+
+        if (opts.destruct) {
+          pluginResult = callInstance(
+            pluginObj,
+            methodName,
+            args,
+            opts,
+            (...args: any[]) => observer.next(args),
+            (...args: any[]) => observer.error(args)
+          );
+        } else {
+          pluginResult = callInstance(
+            pluginObj,
+            methodName,
+            args,
+            opts,
+            observer.next.bind(observer),
+            observer.error.bind(observer)
+          );
+        }
+
+        if (pluginResult && pluginResult.error) {
+          observer.error(pluginResult.error);
+        }
+
+        return () => {
+          try {
+            if (opts.clearWithArgs) {
+              return callInstance(
+                pluginObj,
+                opts.clearFunction,
+                args,
+                opts,
+                observer.next.bind(observer),
+                observer.error.bind(observer)
+              );
+            }
+            return callInstance(pluginObj, opts.clearFunction, []);
+          } catch (e) {
+            console.warn(
+              'Unable to clear the previous observable watch for',
+              pluginObj.constructor.getPluginName(),
+              methodName
+            );
+            console.warn(e);
+          }
+        };
+      });
+    } else if (opts.otherPromise) {
+      return getPromise((resolve: Function, reject: Function) => {
+        let result;
+        if (opts.destruct) {
+          result = callInstance(
+            pluginObj,
+            methodName,
+            args,
+            opts,
+            (...args: any[]) => resolve(args),
+            (...args: any[]) => reject(args)
+          );
+        } else {
+          result = callInstance(pluginObj, methodName, args, opts, resolve, reject);
+        }
+        if (result && result.then) {
+          result.then(resolve, reject);
+        } else {
+          reject();
+        }
+      });
+    } else {
+      let pluginResult: any, rej: Function;
+      const p = getPromise((resolve: Function, reject: Function) => {
+        if (opts.destruct) {
+          pluginResult = callInstance(
+            pluginObj,
+            methodName,
+            args,
+            opts,
+            (...args: any[]) => resolve(args),
+            (...args: any[]) => reject(args)
+          );
+        } else {
+          pluginResult = callInstance(pluginObj, methodName, args, opts, resolve, reject);
+        }
+        rej = reject;
+      });
+      // Angular throws an error on unhandled rejection, but in this case we have already printed
+      // a warning that Cordova is undefined or the plugin is uninstalled, so there is no reason
+      // to error
+      if (pluginResult && pluginResult.error) {
+        p.catch(() => {});
+        typeof rej === 'function' && rej(pluginResult.error);
+      }
+      return p;
+    }
+  };
+}

src/@ionic-native/core/decorators/cordova-function-override.ts

@@ -0,0 +1,22 @@
+import { Observable, Observer } from 'rxjs';
+
+import { checkAvailability, getPlugin } from './common';
+
+function overrideFunction(pluginObj: any, methodName: string): Observable<any> {
+  return new Observable((observer: Observer<any>) => {
+    const availabilityCheck = checkAvailability(pluginObj, methodName);
+
+    if (availabilityCheck === true) {
+      const pluginInstance = getPlugin(pluginObj.constructor.getPluginRef());
+      pluginInstance[methodName] = observer.next.bind(observer);
+      return () => (pluginInstance[methodName] = () => {});
+    } else {
+      observer.error(availabilityCheck);
+      observer.complete();
+    }
+  });
+}
+
+export function cordovaFunctionOverride(pluginObj: any, methodName: string, args: IArguments | any[] = []) {
+  return overrideFunction(pluginObj, methodName);
+}

src/@ionic-native/core/decorators/cordova-instance.ts

@@ -0,0 +1,7 @@
+import { wrapInstance } from './common';
+import { CordovaOptions } from './interfaces';
+
+export function cordovaInstance(pluginObj: any, methodName: string, config: CordovaOptions, args: IArguments | any[]) {
+  args = Array.from(args);
+  return wrapInstance(pluginObj, methodName, config).apply(this, args);
+}

src/@ionic-native/core/decorators/cordova-property.ts

@@ -0,0 +1,14 @@
+import { checkAvailability, getPlugin } from './common';
+
+export function cordovaPropertyGet(pluginObj: any, key: string) {
+  if (checkAvailability(pluginObj, key) === true) {
+    return getPlugin(pluginObj.constructor.getPluginRef())[key];
+  }
+  return null;
+}
+
+export function cordovaPropertySet(pluginObj: any, key: string, value: any) {
+  if (checkAvailability(pluginObj, key) === true) {
+    getPlugin(pluginObj.constructor.getPluginRef())[key] = value;
+  }
+}

src/@ionic-native/core/decorators/cordova.ts

@@ -0,0 +1,6 @@
+import { wrap } from './common';
+import { CordovaOptions } from './interfaces';
+
+export function cordova(pluginObj: any, methodName: string, config: CordovaOptions, args: IArguments | any[]) {
+  return wrap(pluginObj, methodName, config).apply(this, args);
+}