5.22.0

* feat(iamport-cordova): add iamport-cordova plugin on ionic-native

* Update index.ts

* document cordova functions specifically

* fix lint error

* add document befroe function declarations

* Update index.ts

Co-authored-by: Daniel Sogl <daniel@sogls.de>

.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/workflows/nodejs.yml

@@ -0,0 +1,31 @@
+name: Node CI
+
+on: [push]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [12.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: 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
+      env:
+        CI: true

.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: 12
+      - 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: 12
+          registry-url: https://registry.npmjs.org/
+      - run: npm ci
+      - run: npm run shipit
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.NPM_TOKEN}}

.gitignore

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

.vscode/settings.json

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

DEVELOPER.md

@@ -88,8 +88,6 @@ It's just a stub. The `return` is only there to keep the TypeScript type-checker
 
 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.
-
 Next, let's look at the `watchPosition` method.
 
 ```
@@ -115,11 +113,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
 
@@ -194,7 +192,7 @@ Checks if the plugin and property exist before getting/setting the property's va
 
 Example:
 ```ts
-@CordovaProperty
+@CordovaProperty()
 someProperty: string;
 ```
 
@@ -218,4 +216,4 @@ 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,6 +1,5 @@
 [![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](https://ionicframework.com/) mobile app easy.
@@ -10,6 +9,7 @@ Ionic Native wraps plugin callbacks in a Promise or Observable, providing a comm
 ## Installation
 
 Run following command to install Ionic Native in your project.
+
 ```bash
 npm install @ionic-native/core --save
 ```
@@ -22,11 +22,13 @@ For the full Ionic Native documentation, please visit [https://ionicframework.co
 
 ### Basic Usage
 
-To use a plugin, import and add the plugin provider to your `@NgModule`, and then inject it where you wish to use it.
+#### 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,20 +46,18 @@ 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) {
 
-    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}`)
       });
 
@@ -65,28 +65,82 @@ export class MyComponent {
       // watch position
       const watch = geolocation.watchPosition().subscribe(pos => {
         console.log(`lat: ${pos.coords.latitude}, lon: ${pos.coords.longitude}`)
-        this.position = pos;
       });
 
       // to stop watching
       watch.unsubscribe();
     });
-    
+
   }
-  
+
 }
 ```
 
-### Mocking and Browser Development
+#### 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';
 
-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`.
+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:
@@ -95,8 +149,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');
+    });
   }
 }
 ```
@@ -104,71 +158,61 @@ 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: 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](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/ionic-team/ionic-native/blob/master/DEVELOPER.md) for more on how to contribute. :heart:
 
-## Ionic v1 (AngularJS, Angular 1.x) support
-
-For Ionic v1 (AngularJS, Angular 1.x) support, please use version 2 of Ionic Native. See the [2.x README](https://github.com/ionic-team/ionic-native/blob/v2.x/README.md) for usage information.
 
 # Credits
 
 Ibby Hadeed - [@ihadeed](https://github.com/ihadeed)
 
+Daniel Sogl - [@sogldaniel](https://twitter.com/sogldaniel)
+
 Tim Lancina - [@timlancina](https://twitter.com/timlancina)
 
 Mike Hartington - [@mhartington](https://twitter.com/mhartington)

circle.yml

@@ -3,7 +3,7 @@ jobs:
   build:
     working_directory: ~/ionic-native/
     docker:
-      - image: node:7
+      - image: node:12
     steps:
       - checkout
       - restore_cache:
@@ -22,7 +22,7 @@ jobs:
          key: node_modules_{{ checksum "package.json" }}
       - run:
          name: Install node modules
-         command: npm i
+         command: npm ci
       - save_cache:
          key: node_modules_{{ checksum "package.json" }}
          paths:
@@ -33,7 +33,7 @@ jobs:
       - run: bash ./scripts/git/config.sh
       - run:
           name: Build Ionic Native
-          command: npm run build:core && ./node_modules/.bin/tsc
+          command: npm run build
       - run:
           name: Generate README files to ensure docs are valid
           command: npm run readmes

gulpfile.js

@@ -1,51 +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'},
+    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,
       spaced = pluginName.replace(/(?!^)([A-Z])/g, ' $1'),
       kebabCase = _.kebabCase(pluginName);
 
-    return gulp.src(src)
+    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));
-
   } else {
-    console.log("Usage is: gulp plugin:create -n PluginName");
+    console.log('Usage is: gulp plugin:create -n PluginName');
   }
 });

karma.conf.js

@@ -1,55 +0,0 @@
-"use strict";
-
-module.exports = config => {
-
-  const conf = {
-    frameworks: [
-      'jasmine',
-      'karma-typescript'
-    ],
-
-    plugins: [
-      'karma-typescript',
-      'karma-jasmine',
-      'karma-phantomjs-launcher'
-    ],
-
-    preprocessors: {
-      'src/**/*.ts': ['karma-typescript']
-    },
-
-    karmaTypescriptConfig: {
-      bundlerOptions: {
-        entrypoints: /\.spec\.ts$/,
-        transforms: [
-          require("karma-typescript-es6-transform")()
-        ]
-      },
-      compilerOptions: {
-        lib: ['es2015', 'dom'],
-        paths: {
-          "@ionic-native/core": ["./src/@ionic-native/core"]
-        },
-        baseUrl: '.'
-      }
-    },
-
-    files: [
-      { pattern: 'src/**/*.ts', included: true, watched: true }
-    ],
-
-    reporters: ['progress'],
-
-    port: 9876,
-    colors: true,
-    logLevel: config.INFO,
-    autoWatch: true,
-    browsers: [
-      'PhantomJS'
-    ],
-    singleRun: false
-  };
-
-  config.set(conf);
-
-};

package.json

@@ -1,65 +1,80 @@
 {
   "name": "ionic-native",
-  "version": "4.7.0",
+  "version": "5.22.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.4.4",
-    "@angular/compiler-cli": "4.4.4",
-    "@angular/core": "4.4.4",
-    "@types/cordova": "0.0.34",
-    "@types/jasmine": "^2.6.3",
-    "@types/node": "^8.0.50",
-    "canonical-path": "0.0.2",
-    "child-process-promise": "2.2.1",
-    "conventional-changelog-cli": "1.3.4",
-    "cpr": "2.0.0",
-    "cz-conventional-changelog": "2.0.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",
-    "jasmine-core": "^2.6.1",
-    "karma": "^1.7.0",
-    "karma-cli": "^1.0.1",
-    "karma-jasmine": "^1.1.0",
-    "karma-phantomjs-launcher": "^1.0.4",
-    "karma-typescript": "^3.0.1",
-    "karma-typescript-es6-transform": "^1.0.0",
-    "lodash": "4.17.4",
-    "minimist": "1.2.0",
-    "node-html-encoder": "0.0.2",
-    "q": "1.5.0",
-    "queue": "4.2.1",
-    "rimraf": "2.6.1",
-    "rxjs": "5.5.2",
-    "semver": "5.3.0",
-    "tslint": "3.15.1",
-    "tslint-ionic-rules": "0.0.8",
-    "typescript": "~2.4.2",
-    "zone.js": "0.8.18"
-  },
   "scripts": {
-    "start": "npm run test:watch",
+    "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\"",
-    "test": "karma start karma.conf.js --single-run",
-    "test:watch": "karma start karma.conf.js",
-    "readmes": "gulp readmes"
+    "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"
+  },
+  "devDependencies": {
+    "@angular/common": "^9.0.4",
+    "@angular/compiler": "^9.0.4",
+    "@angular/compiler-cli": "^9.0.4",
+    "@angular/core": "^9.0.4",
+    "@types/cordova": "0.0.34",
+    "@types/fs-extra": "^8.1.0",
+    "@types/jest": "^25.1.3",
+    "@types/lodash": "^4.14.149",
+    "@types/node": "^12.12.28",
+    "@types/rimraf": "^2.0.3",
+    "@types/webpack": "^4.41.7",
+    "ajv": "^6.12.0",
+    "async-promise-queue": "^1.0.5",
+    "conventional-changelog-cli": "^2.0.31",
+    "cz-conventional-changelog": "^3.1.0",
+    "dgeni": "^0.4.12",
+    "dgeni-packages": "0.16.10",
+    "fs-extra": "^8.1.0",
+    "gulp": "^4.0.2",
+    "gulp-rename": "^2.0.0",
+    "gulp-replace": "^1.0.0",
+    "gulp-tslint": "^8.1.4",
+    "jest": "^25.1.0",
+    "lodash": "^4.17.15",
+    "minimist": "1.2.0",
+    "natives": "^1.1.6",
+    "rimraf": "^3.0.2",
+    "rxjs": "~6.5.4",
+    "ts-jest": "^25.2.1",
+    "ts-node": "^8.6.2",
+    "tslint": "~5.18.0",
+    "tslint-ionic-rules": "0.0.21",
+    "typedoc": "^0.16.11",
+    "typescript": "~3.7.5",
+    "typescript-tslint-plugin": "0.5.5",
+    "uglifyjs-webpack-plugin": "^2.2.0",
+    "unminified-webpack-plugin": "^2.0.0",
+    "webpack": "^4.41.6",
+    "winston": "^3.2.1",
+    "zone.js": "~0.10.2"
+  },
+  "jest": {
+    "transform": {
+      "^.+\\.tsx?$": "ts-jest"
+    },
+    "testRegex": "(/__tests__/.*|(\\.|/)(test|spec))\\.(js?|ts?)$",
+    "moduleFileExtensions": [
+      "ts",
+      "tsx",
+      "js",
+      "jsx",
+      "json"
+    ]
   },
   "repository": {
     "type": "git",
@@ -72,5 +87,8 @@
     "commitizen": {
       "path": "./node_modules/cz-conventional-changelog"
     }
+  },
+  "dependencies": {
+    "tslib": "1.10.0"
   }
 }

scripts/build/build.js

@@ -1,159 +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 = '^4.2.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);
-let ignoreErrors = false;
-let errors = [];
-
-const index = pluginsToBuild.indexOf('ignore-errors');
-if (index > -1) {
-  ignoreErrors = true;
-  pluginsToBuild.splice(index, 1);
-  console.log('Build will continue even if errors were thrown. Errors will be printed when build finishes.');
-}
-
-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) {
-
-            if (!ignoreErrors) {
-              // oops! something went wrong.
-              console.log(err);
-              callback(`\n\nBuilding ${pluginName} failed.`);
-              return;
-            } else {
-              errors.push(err);
-            }
-
-          }
-
-          // 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.');
-    console.log(err);
-    process.stderr.write(err);
-    process.exit(1);
-  } else if (errors.length) {
-    errors.forEach(e => {
-      console.log(e.message) && console.log('\n');
-      process.stderr.write(err);
-    });
-    console.log('Build complete with errors');
-    process.exit(1);
-  } 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/ionic-team/ionic-native.git"
-  }
-}

scripts/build/helpers.ts

@@ -0,0 +1,126 @@
+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,108 @@
+import * as ts from 'typescript';
+import * as fs from 'fs-extra';
+import * as path from 'path';
+import * as rimraf from 'rimraf';
+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')));
+}
+
+// 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/ionic-team/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,74 @@
+import * as ts from 'typescript';
+import { getMethodsForDecorator } from '../helpers';
+
+function transformImports(file: ts.SourceFile, ctx: ts.TransformationContext, ngcBuild?: boolean) {
+  // remove angular imports
+  if (!ngcBuild) {
+    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,37 @@
+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,49 @@
+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((method.name as any).text),
+        convertValueToLiteral(decoratorArgs),
+        ts.createIdentifier('arguments')
+      ]);
+  }
+
+}

scripts/build/transformers/plugin-class.ts

@@ -0,0 +1,80 @@
+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,67 @@
+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,51 @@
+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,23 +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,
-    "noImplicitAny": true
-  },
-  "files": []
-}

scripts/ci-tests.js

@@ -1,65 +0,0 @@
-const exec = require('child-process-promise').exec;
-let diff;
-exec(`git branch | grep \\* | cut -d ' ' -f2`)
-  .then(output => {
-    if (output.stderr) {
-      return Promise.reject(output.stderr);
-    }
-
-    const branch = output.stdout.trim();
-
-    if (branch !== 'master') {
-
-      console.log('Merging master branch in ...');
-      // not on master branch
-      // let's test the changes that were made
-      return exec(`git merge origin master`);
-    }
-  })
-  .then((output) => {
-    if (output && output.stderr) {
-      return Promise.reject(output.stderr);
-    }
-    console.log('Checking for differences ...');
-    return exec(`git diff --name-status origin master`)
-  })
-  .then((output) => {
-    if (output && output.stderr) {
-      return Promise.reject(output.stderr);
-    }
-
-    diff = output.stdout;
-    diff = diff.replace(/A\s+/g, '');
-    diff = diff.match(/src\/@ionic-native\/plugins\/([a-zA-Z0-9\-]+)\/index\.ts/g);
-
-    if (!diff) process.exit();
-
-    console.log(`${ diff.length } plugins were modified. We will now build them to verify they still work.`);
-
-    return exec('npm run build:core --silent');
-  })
-  .then((output) => {
-
-    if (output && output.stderr) {
-      return Promise.reject(output.stderr);
-    }
-
-    console.log('Built core library successfully ...');
-    console.log('Building plugins ...');
-
-    diff = diff.map(text => text.replace('src/@ionic-native/plugins/', '').replace('/index.ts', ''));
-
-    return exec(`npm run build:modules ${diff.join(' ')} --silent`);
-  })
-  .then((output) => {
-    if (output && output.stderr) {
-      console.log(output.stderr);
-      process.exit(1);
-    }
-    console.log(output.stdout);
-    process.exit();
-  })
-  .catch(e => {
-    console.log(e.message || e);
-    process.exit(1);
-  });

scripts/docs-json/index.ts

@@ -0,0 +1,109 @@
+import * as fs from 'fs-extra';
+import { basename, dirname, resolve } from 'path';
+import { Application } from 'typedoc';
+import { runInNewContext } from 'vm';
+
+import TypeDoc = require('typedoc');
+
+interface Plugin {
+  packageName: string;
+  displayName: string;
+  description: string;
+  platforms: string[];
+  usage: string;
+  repo: string;
+  installVariables: string[];
+  cordovaPlugin: {
+    name: string;
+  };
+}
+
+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');
+  return {
+    packageName,
+    displayName,
+    description,
+    usage,
+    platforms: decorator.platforms,
+    repo: decorator.repo,
+    installVariables: decorator.installVariables,
+    cordovaPlugin: {
+      name: decorator.plugin
+    }
+  };
+}
+
+/**
+ * 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/dgeni/dgeni-config.js

@@ -50,9 +50,9 @@ module.exports = currentVersion => {
 
       // Don't run unwanted processors since we are not using the normal file reading processor
       readFilesProcessor.$enabled = false;
-      readFilesProcessor.basePath = path.resolve(__dirname, '../..');
+      readFilesProcessor.basePath = path.resolve(__dirname, '../../..');
 
-      readTypeScriptModules.basePath = path.resolve(__dirname, '../..');
+      readTypeScriptModules.basePath = path.resolve(__dirname, '../../..');
       readTypeScriptModules.sourceFiles = [
         './src/@ionic-native/plugins/**/*.ts'
       ];

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

@@ -40,7 +40,6 @@ module.exports = currentVersion => {
       computePathsProcessor.pathTemplates = [{
         docTypes: ['class'],
         getOutputPath: doc => doc.originalModule.replace(config.pluginDir + '/', '')
-          .replace('/plugins', '')
           .replace(/\/index$/, '/README.md')
       }];
 
@@ -50,15 +49,15 @@ module.exports = currentVersion => {
     .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, '../..');
+      readFilesProcessor.basePath = path.resolve(__dirname, '../../..');
 
-      readTypeScriptModules.basePath = path.resolve(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/';
+      writeFilesProcessor.outputFolder  = './dist/@ionic-native/';
     })
 
     // Configure rendering

scripts/docs/dgeni/processors/jekyll.js

@@ -10,6 +10,12 @@ module.exports = function jekyll(renderDocsProcessor) {
       // 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() : '';
@@ -18,14 +24,20 @@ module.exports = function jekyll(renderDocsProcessor) {
       });
 
       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 + '/';
         }
+
+        doc.URL = '/' + doc.URL;
       });
 
       const betaDocs = [];

scripts/docs/dgeni/processors/readmes.js

@@ -10,7 +10,7 @@ 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/templates/common.template.html

@@ -187,7 +187,7 @@ docType: "<$ doc.docType $>"
 <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 --save @ionic-native/<$ doc.npmId $>
+$ 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>

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

@@ -6,5 +6,5 @@
 </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>
+  <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

@@ -17,7 +17,7 @@
 
 ```
 $ <@ if prop.install @><$ prop.install $><@ else @>ionic cordova plugin add <$ prop.plugin $><@ endif @>
-$ npm install --save @ionic-native/<$ doc.npmId $>
+$ 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/','') $>)

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/update_docs.sh

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

scripts/docs/update_readmes.sh

@@ -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/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,97 @@
+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.optimize.OccurrenceOrderPlugin(true),
+    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,46 @@
+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,13 @@
+import {
+  cleanupNgx,
+  generateDeclarationFiles,
+  modifyMetadata,
+  transpileNgx,
+  transpileNgxCore
+} from '../build/ngx';
+
+transpileNgxCore();
+transpileNgx();
+generateDeclarationFiles();
+modifyMetadata();
+cleanupNgx();

scripts/tasks/publish.ts

@@ -0,0 +1,114 @@
+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',
+  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<any>((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

@@ -5,14 +5,13 @@
  * - 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 }}

scripts/templates/wrap.tmpl

@@ -5,14 +5,13 @@
  * - 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 }}

scripts/tsconfig.json

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

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

@@ -1,25 +1,26 @@
 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.spec.ts

@@ -1,258 +0,0 @@
-import 'core-js';
-
-import { Observable } from 'rxjs/Observable';
-
-import {
-  Cordova,
-  CordovaCheck,
-  CordovaInstance,
-  CordovaProperty,
-  InstanceProperty,
-  Plugin
-} from './decorators';
-import { IonicNativePlugin } from './ionic-native-plugin';
-import { ERR_CORDOVA_NOT_AVAILABLE, ERR_PLUGIN_NOT_INSTALLED } from './plugin';
-
-declare const window: any;
-
-class TestObject {
-  constructor(public _objectInstance: any) {}
-
-  @InstanceProperty name: string;
-
-  @CordovaInstance({ sync: true })
-  pingSync(): string {
-    return;
-  }
-
-  @CordovaInstance()
-  ping(): Promise<any> {
-    return;
-  }
-}
-
-@Plugin({
-  pluginName: 'TestPlugin',
-  pluginRef: 'testPlugin',
-  repo: '',
-  plugin: 'cordova-plugin-my-plugin',
-  platforms: ['Android', 'iOS']
-})
-class TestPlugin extends IonicNativePlugin {
-  @CordovaProperty name: string;
-
-  @Cordova({ sync: true })
-  pingSync(): string {
-    return;
-  }
-
-  @Cordova()
-  ping(): Promise<string> {
-    return;
-  }
-
-  @CordovaCheck()
-  customPing(): Promise<string> {
-    return Promise.resolve('pong');
-  }
-
-  create(): TestObject {
-    return new TestObject(TestPlugin.getPlugin().create());
-  }
-
-  @Cordova({
-    destruct: true
-  })
-  destructPromise(): Promise<any> {
-    return;
-  }
-
-  @Cordova({
-    destruct: true,
-    observable: true
-  })
-  destructObservable(): Observable<any> {
-    return;
-  }
-}
-
-function definePlugin() {
-  (window as any).testPlugin = {
-    name: 'John Smith',
-    ping: (success: Function, error: Function) => success('pong'),
-    pingSync: () => 'pong',
-    create: function TestObject() {
-      this.pingSync = () => 'pong';
-      this.ping = (success: Function, error: Function) => success('pong');
-      this.name = 'John Smith';
-      return this;
-    },
-    destructPromise: (success: Function) => success('hello', 'world'),
-    destructObservable: (success: Function) => success('hello', 'world')
-  };
-}
-
-describe('Regular Decorators', () => {
-  let plugin: TestPlugin;
-
-  beforeEach(() => {
-    plugin = new TestPlugin();
-    definePlugin();
-  });
-
-  describe('Plugin', () => {
-    it('should set pluginName', () => {
-      expect(TestPlugin.getPluginName()).toEqual('TestPlugin');
-    });
-
-    it('should set pluginRef', () => {
-      expect(TestPlugin.getPluginRef()).toEqual('testPlugin');
-    });
-
-    it('should return original plugin object', () => {
-      expect(TestPlugin.getPlugin()).toEqual(window.testPlugin);
-    });
-
-    it('should return supported platforms', () => {
-      expect(TestPlugin.getSupportedPlatforms()).toEqual(['Android', 'iOS']);
-    });
-  });
-
-  describe('Cordova', () => {
-    it('should do a sync function', () => {
-      expect(plugin.pingSync()).toEqual('pong');
-    });
-
-    it('should do an async function', (done: Function) => {
-      plugin
-        .ping()
-        .then(res => {
-          expect(res).toEqual('pong');
-          done();
-        })
-        .catch(e => {
-          expect(e).toBeUndefined();
-          done('Method should have resolved');
-        });
-    });
-
-    it('should throw plugin_not_installed error', (done: Function) => {
-      delete window.testPlugin;
-      window.cordova = true;
-
-      expect(<any>plugin.pingSync()).toEqual(ERR_PLUGIN_NOT_INSTALLED);
-
-      plugin.ping().catch(e => {
-        expect(e).toEqual(ERR_PLUGIN_NOT_INSTALLED.error);
-        delete window.cordova;
-        done();
-      });
-    });
-
-    it('should throw cordova_not_available error', (done: Function) => {
-      delete window.testPlugin;
-
-      expect(<any>plugin.pingSync()).toEqual(ERR_CORDOVA_NOT_AVAILABLE);
-
-      plugin.ping().catch(e => {
-        expect(e).toEqual(ERR_CORDOVA_NOT_AVAILABLE.error);
-        done();
-      });
-    });
-  });
-
-  describe('CordovaProperty', () => {
-    it('should return property value', () => {
-      expect(plugin.name).toEqual('John Smith');
-    });
-
-    it('should set property value', () => {
-      plugin.name = 'value2';
-      expect(plugin.name).toEqual('value2');
-    });
-  });
-
-  describe('CordovaCheck', () => {
-    it('should run the method when plugin exists', done => {
-      plugin.customPing().then(res => {
-        expect(res).toEqual('pong');
-        done();
-      });
-    });
-
-    it('shouldnt run the method when plugin doesnt exist', done => {
-      delete window.testPlugin;
-      window.cordova = true;
-      plugin.customPing().catch(e => {
-        expect(e).toEqual(ERR_PLUGIN_NOT_INSTALLED.error);
-        done();
-      });
-    });
-  });
-
-  describe('CordovaOptions', () => {
-    describe('destruct', () => {
-      it('should destruct values returned by a Promise', done => {
-        plugin.destructPromise().then((args: any[]) => {
-          expect(args).toEqual(['hello', 'world']);
-          done();
-        });
-      });
-
-      it('should destruct values returned by an Observable', done => {
-        plugin.destructObservable().subscribe((args: any[]) => {
-          expect(args).toEqual(['hello', 'world']);
-          done();
-        });
-      });
-    });
-  });
-});
-
-describe('Instance Decorators', () => {
-  let instance: TestObject, plugin: TestPlugin;
-
-  beforeEach(() => {
-    definePlugin();
-    plugin = new TestPlugin();
-    instance = plugin.create();
-  });
-
-  describe('Instance plugin', () => {});
-
-  describe('CordovaInstance', () => {
-    it('should call instance async method', done => {
-      instance.ping().then(r => {
-        expect(r).toEqual('pong');
-        done();
-      });
-    });
-
-    it('should call instance sync method', () => {
-      expect(instance.pingSync()).toEqual('pong');
-    });
-
-    it('shouldnt call instance method when _objectInstance is undefined', () => {
-      delete instance._objectInstance;
-      instance
-        .ping()
-        .then(r => {
-          expect(r).toBeUndefined();
-        })
-        .catch(e => {
-          expect(e).toBeUndefined();
-        });
-    });
-  });
-
-  describe('InstanceProperty', () => {
-    it('should return property value', () => {
-      expect(instance.name).toEqual('John Smith');
-    });
-
-    it('should set property value', () => {
-      instance.name = 'John Cena';
-      expect(instance.name).toEqual('John Cena');
-    });
-  });
-});

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

@@ -1,333 +0,0 @@
-import 'rxjs/observable/throw';
-
-import { Observable } from 'rxjs/Observable';
-
-import {
-  checkAvailability,
-  instanceAvailability,
-  overrideFunction,
-  wrap,
-  wrapInstance
-} from './plugin';
-import { getPlugin, getPromise } from './util';
-
-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[];
-
-  [key: string]: any;
-}
-
-export interface CordovaOptions {
-  destruct?: boolean;
-  /**
-   * 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;
-}
-
-/**
- * @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(() => {});
-        }
-      },
-      enumerable: true
-    };
-  };
-}
-
-/**
- * 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);
-        }
-      },
-      enumerable: true
-    };
-  };
-}
-
-/**
- * @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): ClassDecorator {
-  return function(cls: any) {
-    // Add these fields to the class
-    for (let prop in config) {
-      cls[prop] = config[prop];
-    }
-
-    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);
-      },
-      enumerable: true
-    };
-  };
-}
-
-/**
- * @private
- *
- * Wrap an instance method
- */
-export function CordovaInstance(opts: CordovaOptions = {}) {
-  return (target: Object, methodName: string) => {
-    return {
-      value: function(...args: any[]) {
-        return wrapInstance(this, methodName, opts).apply(this, args);
-      },
-      enumerable: true
-    };
-  };
-}
-
-/**
- * @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);
-      },
-      enumerable: true
-    };
-  };
-}

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

@@ -1,180 +1,49 @@
-import 'rxjs/add/observable/fromEvent';
+import { fromEvent, Observable } from 'rxjs';
 
-import { Observable } from 'rxjs/Observable';
+import { CordovaOptions } from './interfaces';
 
-import { checkReady } from './bootstrap';
-import { CordovaOptions } from './decorators';
-import { cordovaWarn, getPlugin, getPromise, pluginWarn } from './util';
-
-checkReady();
-
-// declare const window;
-// declare var Promise;
+declare const window: any;
 
 export const ERR_CORDOVA_NOT_AVAILABLE = { error: 'cordova_not_available' };
 export const ERR_PLUGIN_NOT_INSTALLED = { error: 'plugin_not_installed' };
 
-/**
- * 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 (!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')
-  );
-}
-
-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
-  ) {
-    let 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 behaviour.
-      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();
+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 {
-      setSuccessIndex();
-      setErrorIndex();
+      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.'
+      );
     }
-  } 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);
+  };
+
+  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 args;
+
+  return tryNativePromise();
 }
 
-function callCordovaPlugin(
+export function wrapPromise(
   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;
-  }
-}
-
-function wrapPromise(
-  pluginObj: any,
-  methodName: string,
-  args: any[],
-  opts: any = {}
+  opts: CordovaOptions = {}
 ) {
   let pluginResult: any, rej: Function;
   const p = getPromise((resolve: Function, reject: Function) => {
@@ -188,14 +57,7 @@ function wrapPromise(
         (...args: any[]) => reject(args)
       );
     } else {
-      pluginResult = callCordovaPlugin(
-        pluginObj,
-        methodName,
-        args,
-        opts,
-        resolve,
-        reject
-      );
+      pluginResult = callCordovaPlugin(pluginObj, methodName, args, opts, resolve, reject);
     }
     rej = reject;
   });
@@ -209,12 +71,7 @@ function wrapPromise(
   return p;
 }
 
-function wrapOtherPromise(
-  pluginObj: any,
-  methodName: string,
-  args: any[],
-  opts: any = {}
-) {
+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) {
@@ -229,12 +86,7 @@ function wrapOtherPromise(
   });
 }
 
-function wrapObservable(
-  pluginObj: any,
-  methodName: string,
-  args: any[],
-  opts: any = {}
-) {
+function wrapObservable(pluginObj: any, methodName: string, args: any[], opts: any = {}) {
   return new Observable(observer => {
     let pluginResult;
 
@@ -289,7 +141,157 @@ function wrapObservable(
   });
 }
 
-function callInstance(
+/**
+ * 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[],
@@ -300,67 +302,81 @@ function callInstance(
   args = setIndex(args, opts, resolve, reject);
 
   if (instanceAvailability(pluginObj, methodName)) {
-    return pluginObj._objectInstance[methodName].apply(
-      pluginObj._objectInstance,
-      args
+    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}'`);
   }
 }
 
 /**
- * Wrap the event with an observable
  * @private
- * @param event even name
- * @param element The element to attach the event listener to
- * @returns {Observable}
+ * @param pluginName
+ * @param method
  */
-export function wrapEventObservable(
-  event: string,
-  element: any = window
-): Observable<any> {
-  return Observable.fromEvent(element, event);
-}
-
-/**
- * Certain plugins expect the user to override methods in the plugin. For example,
- * window.cordova.plugins.backgroundMode.onactivate = function() { ... }.
- *
- * Unfortunately, this is brittle and would be better wrapped as an Observable. overrideFunction
- * does just this.
- * @private
- */
-export function overrideFunction(
-  pluginObj: any,
-  methodName: string,
-  args: any[],
-  opts: any = {}
-): Observable<any> {
-  return new Observable(observer => {
-    const availabilityCheck = checkAvailability(
-      pluginObj,
-      null,
-      pluginObj.constructor.getPluginName()
-    );
-
-    if (availabilityCheck === true) {
-      const pluginInstance = getPlugin(pluginObj.constructor.getPluginRef());
-      pluginInstance[methodName] = observer.next.bind(observer);
-      return () => (pluginInstance[methodName] = () => {});
+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 {
-      observer.error(availabilityCheck);
-      observer.complete();
+      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 = function(
-  pluginObj: any,
-  methodName: string,
-  opts: CordovaOptions = {}
-) {
+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
@@ -380,11 +396,7 @@ export const wrap = function(
 /**
  * @private
  */
-export function wrapInstance(
-  pluginObj: any,
-  methodName: string,
-  opts: any = {}
-) {
+export function wrapInstance(pluginObj: any, methodName: string, opts: any = {}): Function {
   return (...args: any[]) => {
     if (opts.sync) {
       return callInstance(pluginObj, methodName, args, opts);
@@ -414,7 +426,6 @@ export function wrapInstance(
 
         if (pluginResult && pluginResult.error) {
           observer.error(pluginResult.error);
-          observer.complete();
         }
 
         return () => {
@@ -453,16 +464,9 @@ export function wrapInstance(
             (...args: any[]) => reject(args)
           );
         } else {
-          result = callInstance(
-            pluginObj,
-            methodName,
-            args,
-            opts,
-            resolve,
-            reject
-          );
+          result = callInstance(pluginObj, methodName, args, opts, resolve, reject);
         }
-        if (result && !!result.then) {
+        if (result && result.then) {
           result.then(resolve, reject);
         } else {
           reject();
@@ -481,14 +485,7 @@ export function wrapInstance(
             (...args: any[]) => reject(args)
           );
         } else {
-          pluginResult = callInstance(
-            pluginObj,
-            methodName,
-            args,
-            opts,
-            resolve,
-            reject
-          );
+          pluginResult = callInstance(pluginObj, methodName, args, opts, resolve, reject);
         }
         rej = reject;
       });

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

@@ -0,0 +1,26 @@
+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,12 @@
+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,11 @@
+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);
+}

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

@@ -0,0 +1,12 @@
+export function instancePropertyGet(pluginObj: any, key: string) {
+  if (pluginObj._objectInstance && pluginObj._objectInstance[key]) {
+    return pluginObj._objectInstance[key];
+  }
+  return null;
+}
+
+export function instancePropertySet(pluginObj: any, key: string, value: any) {
+  if (pluginObj._objectInstance) {
+    pluginObj._objectInstance[key] = value;
+  }
+}

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

@@ -0,0 +1,107 @@
+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[];
+
+  [key: string]: any;
+}
+
+export interface CordovaOptions {
+  destruct?: boolean;
+  /**
+   * 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 declare const Plugin: (config: PluginConfig) => ClassDecorator;
+export declare const Cordova: (config?: CordovaOptions) => MethodDecorator;
+export declare const CordovaProperty: () => PropertyDecorator;
+export declare const CordovaInstance: (config?: CordovaOptions) => MethodDecorator;
+export declare const InstanceProperty: () => PropertyDecorator;
+export declare const CordovaCheck: (config?: CordovaOptions) => MethodDecorator;
+export declare const InstanceCheck: (config?: CordovaOptions) => MethodDecorator;
+export declare const CordovaFunctionOverride: () => MethodDecorator;

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

@@ -1,4 +1,14 @@
-export * from './plugin';
-export * from './decorators';
-export * from './util';
-export * from './ionic-native-plugin';
+import { checkReady } from './bootstrap';
+
+export { IonicNativePlugin } from './ionic-native-plugin';
+
+// Decorators
+export { checkAvailability, instanceAvailability, wrap, getPromise } from './decorators/common';
+export * from './decorators/cordova';
+export * from './decorators/cordova-function-override';
+export * from './decorators/cordova-instance';
+export * from './decorators/cordova-property';
+export * from './decorators/instance-property';
+export * from './decorators/interfaces';
+
+checkReady();

src/@ionic-native/core/ionic-native-plugin.spec.ts

@@ -1,74 +0,0 @@
-// This is to verify that new (FileTransfer.getPlugin)() works
-import { CordovaInstance, Plugin } from './decorators';
-import { IonicNativePlugin } from './ionic-native-plugin';
-import { checkAvailability } from './plugin';
-
-class FT {
-  hello(): string {
-    return 'world';
-  }
-}
-
-(window as any).FileTransfer = () => new FT();
-
-@Plugin({
-  plugin: 'cordova-plugin-file-transfer',
-  pluginRef: 'FileTransfer',
-  repo: '',
-  pluginName: 'FileTransfer'
-})
-export class FileTransfer extends IonicNativePlugin {
-  create(): FileTransferObject {
-    let instance: any;
-    if (
-      checkAvailability(
-        FileTransfer.getPluginRef(),
-        null,
-        FileTransfer.getPluginName()
-      ) === true
-    ) {
-      instance = new (FileTransfer.getPlugin())();
-    }
-    return new FileTransferObject(instance);
-  }
-}
-
-export class FileTransferObject {
-  constructor(public _objectInstance: any) {
-    console.info(
-      'Creating a new FileTransferObject with instance: ',
-      _objectInstance
-    );
-  }
-
-  @CordovaInstance({ sync: true })
-  hello(): string {
-    return;
-  }
-}
-
-describe('Mock FileTransfer Plugin', () => {
-  let plugin: FileTransfer, instance: FileTransferObject;
-
-  beforeAll(() => {
-    plugin = new FileTransfer();
-    instance = plugin.create();
-  });
-
-  it('should create a new FileTransfer plugin instance', () => {
-    expect(plugin instanceof FileTransfer).toBeTruthy();
-  });
-
-  it('should create new FileTransferObject instance', () => {
-    expect(instance instanceof FileTransferObject).toBeTruthy();
-  });
-
-  it('FileTransferObject instance should have _objectInstance property', () => {
-    expect(instance._objectInstance).toBeDefined();
-  });
-
-  it('FileTransferObject.hello should return world', () => {
-    console.info('instance hello is', instance.hello());
-    expect(instance.hello()).toEqual('world');
-  });
-});

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

@@ -1,54 +1,62 @@
+import { checkAvailability } from './decorators/common';
+import { get } from './util';
+
 export class IonicNativePlugin {
-  static pluginName: string;
-
-  static pluginRef: string;
-
-  static plugin: string;
-
-  static repo: string;
-
-  static platforms: string[];
-
-  static install: string;
+  static pluginName = '';
+  static pluginRef = '';
+  static plugin = '';
+  static repo = '';
+  static platforms: string[] = [];
+  static install = '';
 
   /**
    * Returns a boolean that indicates whether the plugin is installed
    * @return {boolean}
    */
   static installed(): boolean {
-    return false;
+    const isAvailable = checkAvailability(this.pluginRef) === true;
+    return isAvailable;
   }
 
   /**
    * Returns the original plugin object
    */
-  static getPlugin(): any {}
+  static getPlugin(): any {
+    if (typeof window !== 'undefined') {
+      return get(window, this.pluginRef);
+    }
+    return null;
+  }
 
   /**
    * Returns the plugin's name
    */
   static getPluginName(): string {
-    return;
+    const pluginName = this.pluginName;
+    return pluginName;
   }
 
   /**
    * Returns the plugin's reference
    */
   static getPluginRef(): string {
-    return;
+    const pluginRef = this.pluginRef;
+    return pluginRef;
   }
 
   /**
    * Returns the plugin's install name
    */
   static getPluginInstallName(): string {
-    return;
+    const plugin = this.plugin;
+    return plugin;
   }
 
   /**
    * Returns the plugin's supported platforms
    */
   static getSupportedPlatforms(): string[] {
-    return;
+    const platform = this.platforms;
+    return platform;
   }
 }

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

@@ -0,0 +1,27 @@
+declare const window: any;
+
+/**
+ * Initialize the ionic.native Angular module if we're running in ng1.
+ * This iterates through the list of registered plugins and dynamically
+ * creates Angular 1 services of the form $cordovaSERVICE, ex: $cordovaStatusBar.
+ */
+export function initAngular1(plugins: any) {
+  if (typeof window !== 'undefined' && window.angular) {
+    const ngModule = window.angular.module('ionic.native', []);
+
+    for (const name in plugins) {
+      const serviceName = '$cordova' + name;
+      const cls = plugins[name];
+
+      ((serviceName, cls, name) => {
+        ngModule.service(serviceName, [
+          () => {
+            const funcs = window.angular.copy(cls);
+            funcs.__proto__['name'] = name;
+            return funcs;
+          }
+        ]);
+      })(serviceName, cls, name);
+    }
+  }
+}

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

@@ -3,25 +3,25 @@ declare const window: any;
 /**
  * @private
  */
-export const get = (element: Element | Window, path: string): any => {
+export function get(element: Element | Window, path: string) {
   const paths: string[] = path.split('.');
   let obj: any = element;
-  for (let i: number = 0; i < paths.length; i++) {
+  for (let i = 0; i < paths.length; i++) {
     if (!obj) {
       return null;
     }
     obj = obj[paths[i]];
   }
   return obj;
-};
+}
 
 /**
  * @private
  */
-export const getPromise = (callback: Function): Promise<any> => {
+export function getPromise(callback: Function = () => {}): Promise<any> {
   const tryNativePromise = () => {
-    if (window.Promise) {
-      return new Promise((resolve, reject) => {
+    if (typeof Promise === 'function' || (typeof window !== 'undefined' && window.Promise)) {
+      return new Promise<any>((resolve, reject) => {
         callback(resolve, reject);
       });
     } else {
@@ -32,66 +32,4 @@ export const getPromise = (callback: Function): Promise<any> => {
   };
 
   return tryNativePromise();
-};
-
-/**
- * @private
- * @param pluginRef
- * @returns {null|*}
- */
-export const getPlugin = (pluginRef: string): any => {
-  return get(window, pluginRef);
-};
-
-/**
- * @private
- */
-export const 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 const cordovaWarn = (pluginName: string, method?: string): void => {
-  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'
-    );
-  }
-};
+}

src/@ionic-native/plugins/abbyy-rtr/index.ts

@@ -0,0 +1,341 @@
+import { Injectable } from '@angular/core';
+import { CordovaCheck, IonicNativePlugin, Plugin } from '@ionic-native/core';
+
+declare const AbbyyRtrSdk: any;
+
+/**
+ * JSON object that you can pass as the options argument to change text
+ * capture settings. All keys are optional. Omitting a key means that a
+ * default setting will be used.
+ */
+export interface TextCaptureOptions {
+  /**
+   * The name of the license file. This file must be located in the
+   * www/rtr_assets/ directory in your project.
+   */
+  licenseFileName?: string;
+
+  /**
+   * Recognition languages which can be selected by the user,
+   * for example: ["English", "French", "German"]. Empty array
+   * disables language selection.
+   */
+  selectableRecognitionLanguages?: string[];
+
+  /**
+   * Recognition language selected by default.
+   */
+  recognitionLanguages?: string[];
+
+  /**
+   * Width and height of the recognition area, separated by a
+   * whitespace — for example: "0.8 0.3". The area of interest is
+   * centered in the preview frame, its width and height are
+   * relative to the preview frame size and should be in the [0.0, 1.0] range.
+   */
+  areaOfInterest?: string;
+
+  /**
+   * Whether to stop the plugin as soon as the result status is
+   * "Stable" (see Result status). When enabled (true), the
+   * recognition process can be stopped automatically. When
+   * disabled (false), recognition can be stopped only manually
+   * by user.
+   */
+  stopWhenStable?: boolean;
+
+  /**
+   * Show (true) or hide (false) the flashlight button in the text
+   * capture dialog.
+   */
+  isFlashlightVisible?: boolean;
+
+  /**
+   * Show (true) or hide (false) the stop button in the text
+   * capture dialog. When the user taps stop, RTR SDK returns
+   * the latest recognition result.
+   */
+  isStopButtonVisible?: boolean;
+
+  /**
+   * Specify the orientation, possible values 'landscape' or 'portrait'.
+   */
+  orientation?: string;
+}
+
+/**
+ * JSON object that represents text recognition results.
+ * The callback you implement should parse this object and show results to user.
+ */
+export interface TextCaptureResult {
+  /**
+   * An array of objects representing recognized lines of text.
+   * These objects have the following keys:
+   * · text (string): the recognized text.
+   * · quadrangle (string): vertex coordinates of the bounding quadrangle,
+   *   a string of 8 integers separated with whitespaces ("x1 y1 ... x4 y4"),
+   *   goes clockwise starting from the bottom left.
+   * · rect (string): position and size of the bounding rectangle,
+   *   a string of 4 integers separated with whitespaces ("x y width height").
+   */
+  textLines: { text: string; quadrangle: string; rect?: string }[];
+
+  /**
+   * Additional information. This object has the following keys:
+   * · stabilityStatus (string): result stability status.
+   *   See Result status for details.
+   * · userAction (string): the user's action which stopped the plugin,
+   *   if any. Can be "Manually Stopped" if the stop button has been used,
+   *   and "Canceled" if the user canceled processing. If the plugin has
+   *   stopped automatically, the userAction key is not present in resultInfo.
+   * · frameSize (string): full size of the preview frame, a string
+   *   with 2 integers separated with a whitespace ("720 1280").
+   * · recognitionLanguages (string array): languages used for recognition,
+   *   the array contains language identifiers (["English", "French", "German"]).
+   */
+  resultInfo: {
+    stabilityStatus: string;
+    userAction: string;
+    frameSize: string;
+    recognitionLanguages: string[];
+  };
+
+  /**
+   * Error details. This key is present only if an error occurs.
+   * The value is an object which has a single key:
+   * · description (string): human-readable error description.
+   */
+  error?: {
+    description: string;
+  };
+}
+
+/**
+ * JSON object that you can pass as the options argument to change data
+ * capture settings. All keys are optional. Omitting a key means that a default
+ * setting will be used, except the profile and customDataCaptureScenario
+ * keys: you must specify either one of them, but not both at the same time.
+ */
+export interface DataCaptureOptions {
+  /**
+   * The predefined data capture profile to use, for example: "MRZ".
+   * Note: For the list of supported documents, see Specifications — Data
+   * Capture Profiles in the ABBYY Real-Time Recognition SDK 1 Developer's Guide.
+   */
+  profile?: string;
+
+  /**
+   * Custom data capture settings. This object has the following keys:
+   * · name (string): the name of your custom data capture scenario, required.
+   * · description (string): a more detailed description. This key is optional;
+   *   if not given, it will be assigned the same value as name.
+   * · recognitionLanguages (string array): recognition languages to use.
+   *   Default is ["English"].
+   * · fields (object array): describes data fields to capture. Each object
+   *   in this array has a single regEx key; its value is a string containing
+   *   the regular expression that should be matched when capturing a field.
+   */
+  customDataCaptureScenario?: {
+    name: string;
+    description: string;
+    recognitionLanguages: string[];
+    fields: { regEx: string }[];
+  };
+
+  /**
+   * The name of the license file. This file must be located in the
+   * www/rtr_assets/ directory in your project.
+   */
+  licenseFileName?: string;
+
+  /**
+   * Width and height of the recognition area, separated by a
+   * whitespace — for example: "0.8 0.3". The area of interest is
+   * centered in the preview frame, its width and height are
+   * relative to the preview frame size and should be in the [0.0, 1.0] range.
+   */
+  areaOfInterest?: string;
+
+  /**
+   * Whether to stop the plugin as soon as the result status is
+   * "Stable" (see Result status). When enabled (true), the
+   * recognition process can be stopped automatically. When
+   * disabled (false), recognition can be stopped only manually
+   * by user.
+   */
+  stopWhenStable?: boolean;
+
+  /**
+   * Show (true) or hide (false) the flashlight button in the text
+   * capture dialog.
+   */
+  isFlashlightVisible?: boolean;
+
+  /**
+   * Show (true) or hide (false) the stop button in the text
+   * capture dialog. When the user taps stop, RTR SDK returns
+   * the latest recognition result.
+   */
+  isStopButtonVisible?: boolean;
+
+  /**
+   * Specify the orientation, possible values 'landscape' or 'portrait'.
+   */
+  orientation?: string;
+}
+
+/**
+ * JSON object that represents data recognition results. The callback you
+ * implement should parse this object and show results to user.
+ */
+export interface DataCaptureResult {
+  /**
+   * The data scheme which was applied during data capture.
+   * The value is an object which has two keys:
+   * · id (string): the internal scheme identifier.
+   * · name (string): the scheme name.
+   * If you had defined a custom data capture scenario in options, both the
+   * id and name will be the same as the scenario name you specified. If
+   * you selected a predefined profile, the id and name are specified by the
+   * profile. If an error occurs during processing, the dataScheme key is not
+   * present in the result.
+   */
+  dataScheme?: {
+    id: string;
+    name: string;
+  };
+
+  /**
+   * Recognized data fields. Each object in the array represents a separate
+   * data field. The data field objects have the following keys:
+   * · id (string): the internal identifier of the field.
+   * · name (string): the field name.
+   * Similarly to dataScheme, in custom scenarios both id and name are the same
+   * as the scenario name you specified (currently custom scenarios allow
+   * only 1 recognized field).
+   * · text (string): full text of the field.
+   * · quadrangle (string): vertex coordinates of the bounding quadrangle, a
+   *   string of 8 integers separated with whitespaces ("x1 y1 ... x4 y4"),
+   *   goes clockwise starting from the bottom left.
+   * · components (object array): an array of objects representing field
+   *   components, that is, the text fragments found on the image, which
+   *   constitute the field.
+   * In the components array each element is an object with the following keys:
+   * · text (string): text of this fragment.
+   * · quadrangle (string): vertex coordinates of the bounding quadrangle of
+   *   this fragment, similar to the field's quadrangle.
+   * · rect (string): position and size of the bounding rectangle, a string
+   *   of 4 integers separated with whitespaces ("x y width height").
+   */
+  dataFields: {
+    id: string;
+    name: string;
+    text: string;
+    quadrangle: string;
+    components: {
+      text: string;
+      quadrangle: string;
+      rect: string;
+    };
+  };
+
+  /**
+   * Additional information. This object has the following keys:
+   * · stabilityStatus (string): result stability status.
+   *   See Result status for details.
+   * · userAction (string): the user's action which stopped the plugin,
+   *   if any. Can be "Manually Stopped" if the stop button has been used,
+   *   and "Canceled" if the user canceled processing. If the plugin has
+   *   stopped automatically, the userAction key is not present in resultInfo.
+   * · frameSize (string): full size of the preview frame, a string
+   *   with 2 integers separated with a whitespace ("720 1280").
+   */
+  resultInfo: {
+    stabilityStatus: string;
+    userAction: string;
+    frameSize: string;
+  };
+
+  /**
+   * Error details. This key is present only if an error occurs.
+   * The value is an object which has a single key:
+   * · description (string): human-readable error description.
+   */
+  error?: {
+    description: string;
+  };
+}
+
+/**
+ * @name ABBYY Real-Time Recognition
+ * @description
+ * This plugin allows to use the Text Capture and Data Capture features of
+ * ABBYY Real-Time Recognition SDK (RTR SDK) in apps.
+ *
+ * @usage
+ * ```typescript
+ * import { AbbyyRTR } from '@ionic-native/abbyy-rtr/ngx';
+ *
+ *
+ * constructor(private abbyyRTR: AbbyyRTR) { }
+ *
+ * ...
+ *
+ *
+ * this.abbyyRTR.startTextCapture(options)
+ *   .then((res: any) => console.log(res))
+ *   .catch((error: any) => console.error(error));
+ *
+ *
+ * this.abbyyRTR.startDataCapture(options)
+ *   .then((res: any) => console.log(res))
+ *   .catch((error: any) => console.error(error));
+ *
+ * ```
+ */
+@Plugin({
+  pluginName: 'AbbyyRTR',
+  plugin: 'cordova-plugin-abbyy-rtr-sdk',
+  pluginRef: 'AbbyyRtrSdk',
+  repo: 'https://github.com/abbyysdk/RTR-SDK.Cordova',
+  install: 'ionic cordova plugin add cordova-plugin-abbyy-rtr-sdk',
+  platforms: ['Android', 'iOS']
+})
+@Injectable()
+export class AbbyyRTR extends IonicNativePlugin {
+  /**
+   * Opens a modal dialog with controls for the Text Capture scenario.
+   * @param {TextCaptureOptions} options
+   * @return {Promise<TextCaptureResult>}
+   */
+  @CordovaCheck()
+  startTextCapture(options: TextCaptureOptions): Promise<TextCaptureResult> {
+    return new Promise<any>((resolve, reject) => {
+      AbbyyRtrSdk.startTextCapture((result: DataCaptureResult) => {
+        if (result.error) {
+          reject(result);
+        } else {
+          resolve(result);
+        }
+      }, options);
+    });
+  }
+
+  /**
+   * Opens a modal dialog with controls for the Data Capture scenario.
+   * @param {DataCaptureOptions} options
+   * @return {Promise<DataCaptureResult>}
+   */
+  @CordovaCheck()
+  startDataCapture(options: DataCaptureOptions): Promise<DataCaptureResult> {
+    return new Promise<any>((resolve, reject) => {
+      AbbyyRtrSdk.startDataCapture((result: DataCaptureResult) => {
+        if (result.error) {
+          reject(result);
+        } else {
+          resolve(result);
+        }
+      }, options);
+    });
+  }
+}

src/@ionic-native/plugins/action-sheet/index.ts

@@ -62,7 +62,7 @@ export interface ActionSheetOptions {
  *
  * @usage
  * ```typescript
- * import { ActionSheet, ActionSheetOptions } from '@ionic-native/action-sheet';
+ * import { ActionSheet, ActionSheetOptions } from '@ionic-native/action-sheet/ngx';
  *
  * constructor(private actionSheet: ActionSheet) { }
  *
@@ -79,7 +79,7 @@ export interface ActionSheetOptions {
  *   addDestructiveButtonWithLabel: 'Delete',
  *   androidTheme: this.actionSheet.ANDROID_THEMES.THEME_HOLO_DARK,
  *   destructiveButtonLast: true
- * };
+ * }
  *
  * this.actionSheet.show(options).then((buttonIndex: number) => {
  *   console.log('Button pressed: ' + buttonIndex);

src/@ionic-native/plugins/adjust/index.ts

@@ -0,0 +1,461 @@
+import { Injectable } from '@angular/core';
+import { Cordova, IonicNativePlugin, Plugin } from '@ionic-native/core';
+
+export class AdjustEvent {
+  private eventToken: string;
+  private revenue: number;
+  private currency: string;
+  private transactionId: string;
+  private callbackId: string;
+  private callbackParameters: string[] = [];
+  private partnerParameters: string[] = [];
+
+  constructor(eventToken: string) {
+    this.eventToken = eventToken;
+  }
+
+  setRevenue(revenue: number, currency: string): void {
+    this.revenue = revenue;
+    this.currency = currency;
+  }
+
+  addCallbackParameter(key: string, value: string): void {
+    this.callbackParameters.push(key);
+    this.callbackParameters.push(value);
+  }
+
+  addPartnerParameter(key: string, value: string): void {
+    this.partnerParameters.push(key);
+    this.partnerParameters.push(value);
+  }
+
+  setTransactionId(transactionId: string) {
+    this.transactionId = transactionId;
+  }
+
+  setCallbackId(callbackId: string) {
+    this.callbackId = callbackId;
+  }
+}
+
+export class AdjustConfig {
+  private appToken: string;
+  private environment: AdjustEnvironment;
+  private sdkPrefix: string;
+  private delayStart = 0.0;
+  private logLevel: AdjustLogLevel = null;
+  private defaultTracker: string = null;
+  private sendInBackground: boolean = null;
+  private shouldLaunchDeeplink: boolean = null;
+  private eventBufferingEnabled: boolean = null;
+  private userAgent: string = null;
+  private isDeviceKnown: boolean = null;
+  private secretId: number = null;
+  private info1: number = null;
+  private info2: number = null;
+  private info3: number = null;
+  private info4: number = null;
+  private processName: string = null; // Android only
+
+  private attributionCallback: (attribution: AdjustAttribution) => void = null;
+  private eventTrackingSucceededCallback: (event: AdjustEventSuccess) => void = null;
+  private eventTrackingFailedCallback: (event: AdjustEventFailure) => void = null;
+  private sessionTrackingSucceededCallback: (session: AdjustSessionSuccess) => void = null;
+  private sessionTrackingFailedCallback: (session: AdjustSessionFailure) => void = null;
+  private deferredDeeplinkCallback: (uri: string) => void = null;
+
+  constructor(appToken: string, environment: AdjustEnvironment) {
+    this.appToken = appToken;
+    this.environment = environment;
+  }
+
+  setAppSecret(secretId: number, info1: number, info2: number, info3: number, info4: number): void {
+    this.secretId = secretId;
+    this.info1 = info1;
+    this.info2 = info2;
+    this.info3 = info3;
+    this.info4 = info4;
+  }
+
+  setDelayStart(delayStart: number) {
+    this.delayStart = delayStart;
+  }
+
+  setLogLevel(logLevel: AdjustLogLevel) {
+    this.logLevel = logLevel;
+  }
+
+  setDefaultTracker(defaultTracker: string) {
+    this.defaultTracker = defaultTracker;
+  }
+
+  setSendInBackground(sendInBackground: boolean) {
+    this.sendInBackground = sendInBackground;
+  }
+
+  setShouldLaunchDeeplink(shouldLaunchDeeplink: boolean) {
+    this.shouldLaunchDeeplink = shouldLaunchDeeplink;
+  }
+
+  setEventBufferingEnabled(eventBufferingEnabled: boolean) {
+    this.eventBufferingEnabled = eventBufferingEnabled;
+  }
+
+  setUserAgent(userAgent: string) {
+    this.userAgent = userAgent;
+  }
+
+  setDeviceKnown(isDeviceKnown: boolean) {
+    this.isDeviceKnown = isDeviceKnown;
+  }
+
+  setProcessName(processName: string) {
+    this.processName = processName;
+  }
+
+  setAttributionCallbackListener(attributionCallback: (attribution: AdjustAttribution) => void) {
+    this.attributionCallback = attributionCallback;
+  }
+
+  setEventTrackingSucceededCallbackListener(
+    eventTrackingSucceededCallback: (event: AdjustEventSuccess) => void
+  ) {
+    this.eventTrackingSucceededCallback = eventTrackingSucceededCallback;
+  }
+
+  setEventTrackingFailedCallbackListener(
+    eventTrackingFailedCallback: (event: AdjustEventFailure) => void
+  ) {
+    this.eventTrackingFailedCallback = eventTrackingFailedCallback;
+  }
+
+  setSessionTrackingSucceededCallbackListener(
+    sessionTrackingSucceededCallback: (session: AdjustSessionSuccess) => void
+  ) {
+    this.sessionTrackingSucceededCallback = sessionTrackingSucceededCallback;
+  }
+
+  setSessionTrackingFailedCallbackListener(
+    sessionTrackingFailedCallback: (session: AdjustSessionFailure) => void
+  ) {
+    this.sessionTrackingFailedCallback = sessionTrackingFailedCallback;
+  }
+
+  setDeferredDeeplinkCallbackListener(deferredDeeplinkCallback: (uri: string) => void) {
+    this.deferredDeeplinkCallback = deferredDeeplinkCallback;
+  }
+
+  private getAttributionCallback() {
+    return this.attributionCallback;
+  }
+
+  private getEventTrackingSucceededCallback() {
+    return this.eventTrackingSucceededCallback;
+  }
+
+  private getEventTrackingFailedCallback() {
+    return this.eventTrackingFailedCallback;
+  }
+
+  private getSessionTrackingSucceededCallback() {
+    return this.sessionTrackingSucceededCallback;
+  }
+
+  private getSessionTrackingFailedCallback() {
+    return this.sessionTrackingFailedCallback;
+  }
+
+  private getDeferredDeeplinkCallback() {
+    return this.deferredDeeplinkCallback;
+  }
+
+  private hasAttributionListener() {
+    return this.attributionCallback !== null;
+  }
+
+  private hasEventTrackingSucceededListener() {
+    return this.eventTrackingSucceededCallback !== null;
+  }
+
+  private hasEventTrackingFailedListener() {
+    return this.eventTrackingFailedCallback !== null;
+  }
+
+  private hasSessionTrackingSucceededListener() {
+    return this.sessionTrackingSucceededCallback !== null;
+  }
+
+  private hasSessionTrackingFailedListener() {
+    return this.sessionTrackingFailedCallback !== null;
+  }
+
+  private hasDeferredDeeplinkCallbackListener() {
+    return this.deferredDeeplinkCallback !== null;
+  }
+}
+
+export interface AdjustAttribution {
+  trackerToken: string;
+  trackerName: string;
+  network: string;
+  campaign: string;
+  adgroup: string;
+  creative: string;
+  clickLabel: string;
+  adid: string;
+}
+
+export interface AdjustSessionSuccess {
+  message: string;
+  timestamp: string;
+  adid: string;
+  jsonResponse: string;
+}
+
+export interface AdjustSessionFailure {
+  message: string;
+  timestamp: string;
+  adid: string;
+  willRetry: boolean;
+  jsonResponse: string;
+}
+
+export interface AdjustEventSuccess {
+  message: string;
+  timestamp: string;
+  adid: string;
+  eventToken: string;
+  callbackId: string;
+  jsonResponse: string;
+}
+
+export interface AdjustEventFailure {
+  message: string;
+  timestamp: string;
+  adid: string;
+  eventToken: string;
+  willRetry: boolean;
+  callbackId: string;
+  jsonResponse: string;
+}
+
+export enum AdjustEnvironment {
+  Sandbox = 'sandbox',
+  Production = 'production'
+}
+
+export enum AdjustLogLevel {
+  Verbose = 'VERBOSE',
+  Debug = 'DEBUG',
+  Info = 'INFO',
+  Warn = 'WARN',
+  Error = 'ERROR',
+  Assert = 'ASSERT',
+  Suppress = 'SUPPRESS'
+}
+
+/**
+ * @name Adjust
+ * @description
+ * This is the Ionic Cordova SDK of Adjust™. You can read more about Adjust™ at adjust.com.
+ *
+ * Requires Cordova plugin: `com.adjust.sdk`. For more info, please see the [Adjust Cordova SDK](https://github.com/adjust/cordova_sdk)
+ *
+ * @usage
+ * ```typescript
+ *  import { Adjust, AdjustConfig, AdjustEnvironment } from '@ionic-native/adjust/ngx';
+ *
+ *  constructor(private adjust: Adjust) { }
+ *
+ *  ...
+ *
+ *  const config = new AdjustConfig('APP-TOKEN-HERE', AdjustEnvironment.Sandbox);
+ *  config.logLevel = AdjustLogLevel.Verbose;
+ *  // Set other config properties.
+ *  adjust.create(config);
+ *
+ * ```
+ * @interfaces
+ * AdjustAttribution
+ * AdjustSessionSuccess
+ * AdjustSessionFailure
+ * AdjustEventSuccess
+ * AdjustEventFailure
+ * @classes
+ * AdjustEvent
+ * AdjustConfig
+ * @enums
+ * AdjustEnvironment
+ * AdjustLogLevel
+ */
+@Plugin({
+  pluginName: 'Adjust',
+  plugin: 'com.adjust.sdk',
+  pluginRef: 'Adjust',
+  repo: 'https://github.com/adjust/cordova_sdk',
+  platforms: ['Android', 'iOS']
+})
+@Injectable()
+export class Adjust extends IonicNativePlugin {
+  /**
+   * This method initializes Adjust SDK
+   * @param {AdjustConig} config Adjust config object used as starting options
+   */
+  @Cordova({ sync: true })
+  create(config: AdjustConfig): void {}
+
+  /**
+   * This method tracks an event
+   * @param {AdjustEvent} event Adjust event object to be tracked
+   */
+  @Cordova({ sync: true })
+  trackEvent(event: AdjustEvent): void {}
+
+  /**
+   * This method sets offline mode on or off
+   * @param {boolean} enabled set to true for offline mode on
+   */
+  @Cordova({ sync: true })
+  setOfflineMode(enabled: boolean): void {}
+
+  /**
+   * By making this call, the Adjust SDK will try to find if there is any new attribution info inside of the deep link and if any, it will be sent to the Adjust backend.
+   * @param {string} url URL of the deeplink
+   */
+  @Cordova({ sync: true })
+  appWillOpenUrl(url: string): void {}
+
+  /**
+   * You can disable/enable the Adjust SDK from tracking by invoking this method
+   * @param {boolean} enabled set to false to disable SDK
+   */
+  @Cordova({ sync: true })
+  setEnabled(enabled: boolean): void {}
+
+  /**
+   * To send us the push notification token, add the following call to Adjust whenever you get your token in the app or when it gets updated.
+   * Push tokens are used for Audience Builder and client callbacks, and they are required for the upcoming uninstall tracking feature.
+   * @param {string} pushToken push token value
+   */
+  @Cordova({ sync: true })
+  setPushToken(pushToken: string): void {}
+
+  /**
+   * Check if the Adjust SDK is currently enabled by calling this function
+   * @returns {Promise<boolean>}
+   */
+  @Cordova()
+  isEnabled(): Promise<boolean> {
+    return;
+  }
+
+  /**
+   * In accordance with article 17 of the EU's General Data Protection Regulation (GDPR), you can notify Adjust when a user has exercised their right to be forgotten.
+   * Calling the following method will instruct the Adjust SDK to communicate the user's choice to be forgotten to the Adjust backend
+   */
+  @Cordova({ sync: true })
+  gdprForgetMe(): void {}
+
+  /**
+   * Function used to get Google AdId
+   * @return {Promise<string>} Returns a promise with google AdId value
+   */
+  @Cordova()
+  getGoogleAdId(): Promise<string> {
+    return;
+  }
+
+  /**
+   * If you need to obtain the Amazon Advertising ID, you can make a call to this function.
+   * @return {Promise<string>} Returns a promise with anazib adv. ID
+   */
+  @Cordova()
+  getAmazonAdId(): Promise<string> {
+    return;
+  }
+
+  /**
+   * To obtain the IDFA, call this function
+   * @return {Promise<string>} Returns a promise with IDFA string value
+   */
+  @Cordova()
+  getIdfa(): Promise<string> {
+    return;
+  }
+
+  /**
+   * For every device with your app installed on it, the Adjust backend generates a unique Adjust device identifier (adid).
+   * In order to obtain this identifier, call this function
+   * @return {Promise<string>} Returns a promise with adid value
+   */
+  @Cordova()
+  getAdid(): Promise<string> {
+    return;
+  }
+
+  /**
+   * If you want to access information about a user's current attribution whenever you need it, you can make a call to this function
+   * @return {Promise<AdjustAttribution>} Returns a promise with AdjustAttribution object
+   */
+  @Cordova()
+  getAttribution(): Promise<AdjustAttribution> {
+    return;
+  }
+
+  /**
+   * Get the information about version of the SDK used
+   * @return {Promise<string>} Returns a promise with sdk version information
+   */
+  @Cordova()
+  getSdkVersion(): Promise<string> {
+    return;
+  }
+
+  /**
+   * Method used to add session callback parameters
+   * @param key key
+   * @param value value
+   */
+  @Cordova({ sync: true })
+  addSessionCallbackParameter(key: string, value: string): void {}
+
+  /**
+   * Remove a specific session callback parameter by passing the desiring key to this method
+   * @param key key
+   */
+  @Cordova({ sync: true })
+  removeSessionCallbackParameter(key: string): void {}
+
+  /**
+   * If all keys and values from the session callback parameters have to be removed, call this method
+   */
+  @Cordova({ sync: true })
+  resetSessionCallbackParameters(): void {}
+
+  /**
+   * Method used to add session partner parameters
+   * @param key key
+   * @param value value
+   */
+  @Cordova({ sync: true })
+  addSessionPartnerParameter(key: string, value: string): void {}
+
+  /**
+   * Remove a specific session partner parameter by passing the desiring key to this method
+   * @param key key
+   */
+  @Cordova({ sync: true })
+  removeSessionPartnerParameter(key: string): void {}
+
+  /**
+   * If all keys and values from the session partner parameters have to be removed, call this method
+   */
+  @Cordova({ sync: true })
+  resetSessionPartnerParameters(): void {}
+
+  /**
+   * This method call will make the Adjust SDK send the initial install session and any events created, if they were not sent after delay start was set and it's delay expired.
+   */
+  @Cordova({ sync: true })
+  sendFirstPackages(): void {}
+}

src/@ionic-native/plugins/admob-free/index.ts

@@ -1,8 +1,6 @@
-import 'rxjs/add/observable/fromEvent';
-
 import { Injectable } from '@angular/core';
 import { Cordova, IonicNativePlugin, Plugin } from '@ionic-native/core';
-import { Observable } from 'rxjs/Observable';
+import { Observable, fromEvent } from 'rxjs';
 
 export interface AdMobFreeBannerConfig {
   /**
@@ -68,10 +66,13 @@ export interface AdMobFreeRewardVideoConfig {
 /**
  * @name AdMob Free
  * @description
+ * A free, no ad-sharing version of Google AdMob plugin for Cordova.
+ *
+ * Requires Cordova plugin: `cordova-plugin-admob-free`. For more info, please see the [AdMob Free plugin docs](https://github.com/ratson/cordova-plugin-admob-free).
  *
  * @usage
  * ```typescript
- * import { AdMobFree, AdMobFreeBannerConfig } from '@ionic-native/admob-free';
+ * import { AdMobFree, AdMobFreeBannerConfig } from '@ionic-native/admob-free/ngx';
  *
  *
  * constructor(private admobFree: AdMobFree) { }
@@ -147,7 +148,7 @@ export class AdMobFree extends IonicNativePlugin {
    * @return {Observable<any>}
    */
   on(event: string): Observable<any> {
-    return Observable.fromEvent(document, event);
+    return fromEvent(document, event);
   }
 
   /**
@@ -177,7 +178,7 @@ export class AdMobFree extends IonicNativePlugin {
   plugin: 'cordova-plugin-admob-free',
   pluginRef: 'admob.banner'
 })
-export class AdMobFreeBanner {
+export class AdMobFreeBanner extends IonicNativePlugin {
   /**
    * Update config
    * @param options
@@ -233,7 +234,7 @@ export class AdMobFreeBanner {
   plugin: 'cordova-plugin-admob-free',
   pluginRef: 'admob.interstitial'
 })
-export class AdMobFreeInterstitial {
+export class AdMobFreeInterstitial extends IonicNativePlugin {
   /**
    * Update config
    * @param options
@@ -280,7 +281,7 @@ export class AdMobFreeInterstitial {
   plugin: 'cordova-plugin-admob-free',
   pluginRef: 'admob.rewardvideo'
 })
-export class AdMobFreeRewardVideo {
+export class AdMobFreeRewardVideo extends IonicNativePlugin {
   /**
    * Update config
    * @param {AdMobFreeRewardVideoConfig} options Admob reward config

src/@ionic-native/plugins/admob-plus/index.ts

@@ -0,0 +1,94 @@
+import { Injectable } from '@angular/core';
+import { Cordova, IonicNativePlugin, Plugin } from '@ionic-native/core';
+import { Observable, fromEvent } from 'rxjs';
+
+export type AdUnitIDOption = string | {
+    android: string;
+    ios: string;
+};
+
+/**
+ * @name AdMob Plus
+ * @description
+ * AdMob Plus is the successor of cordova-plugin-admob-free, which provides a cleaner API and build with modern tools.
+ */
+@Plugin({
+    plugin: 'cordova-admob-plus',
+    pluginName: 'AdMob',
+    pluginRef: 'admob.banner',
+    repo: 'https://github.com/admob-plus/admob-plus',
+    platforms: ['Android', 'iOS']
+})
+export class Banner {
+    @Cordova({ otherPromise: true })
+    hide(): Promise<any> {
+        return Promise.resolve();
+    }
+
+    @Cordova({ otherPromise: true })
+    show(opts: { id?: AdUnitIDOption }): Promise<any> {
+        return Promise.resolve();
+    }
+}
+
+@Plugin({
+    plugin: 'cordova-admob-plus',
+    pluginName: 'AdMob',
+    pluginRef: 'admob.interstitial',
+})
+export class Interstitial {
+    @Cordova({ otherPromise: true })
+    load(opts: { id?: AdUnitIDOption }): Promise<any> {
+        return Promise.resolve();
+    }
+
+    @Cordova({ otherPromise: true })
+    show(): Promise<any> {
+        return Promise.resolve();
+    }
+}
+
+@Plugin({
+    plugin: 'cordova-admob-plus',
+    pluginName: 'AdMob',
+    pluginRef: 'admob.rewardVideo',
+})
+export class RewardVideo {
+    @Cordova({ otherPromise: true })
+    load(opts: { id?: AdUnitIDOption }): Promise<any> {
+        return Promise.resolve();
+    }
+
+    @Cordova({ otherPromise: true })
+    show(): Promise<any> {
+        return Promise.resolve();
+    }
+}
+
+@Plugin({
+    platforms: ['Android', 'iOS'],
+    plugin: 'cordova-admob-plus',
+    pluginName: 'AdMob',
+    pluginRef: 'admob',
+    repo: 'https://github.com/admob-plus/admob-plus',
+})
+@Injectable()
+export class AdMob extends IonicNativePlugin {
+    banner = new Banner();
+    interstitial = new Interstitial();
+    rewardVideo = new RewardVideo();
+
+    @Cordova({ otherPromise: true })
+    setAppMuted(value: boolean): Promise<any> {
+        return Promise.resolve();
+    }
+
+    @Cordova({ otherPromise: true })
+    setAppVolume(value: number): Promise<any> {
+        return Promise.resolve();
+    }
+
+    on(event: string): Observable<any> {
+        return fromEvent(document, event);
+    }
+}

src/@ionic-native/plugins/admob-pro/index.ts

@@ -1,6 +1,6 @@
 import { Injectable } from '@angular/core';
 import { Cordova, IonicNativePlugin, Plugin } from '@ionic-native/core';
-import { Observable } from 'rxjs/Observable';
+import { Observable } from 'rxjs';
 
 export type AdSize =
   | 'SMART_BANNER'
@@ -106,8 +106,8 @@ export interface AdExtras {
  * IMPORTANT NOTICE: this plugin takes a percentage out of your earnings if you profit more than $1,000. Read more about this on the plugin's repo. For a completely free alternative, see [AdMobPro Free](../admob-free).
  * @usage
  * ```typescript
- * import { AdMobPro } from '@ionic-native/admob-pro';
- * import { Platform } from 'ionic-angular';
+ * import { AdMobPro } from '@ionic-native/admob-pro/ngx';
+ * import { Platform } from '@ionic/angular';
  *
  * constructor(private admob: AdMobPro, private platform: Platform ) { }
  *
@@ -275,7 +275,7 @@ export class AdMobPro extends IonicNativePlugin {
   @Cordova({
     eventObservable: true,
     event: 'onAdFailLoad',
-    element: document
+    element: 'document'
   })
   onAdFailLoad(): Observable<any> {
     return;
@@ -288,7 +288,7 @@ export class AdMobPro extends IonicNativePlugin {
   @Cordova({
     eventObservable: true,
     event: 'onAdLoaded',
-    element: document
+    element: 'document'
   })
   onAdLoaded(): Observable<any> {
     return;
@@ -301,7 +301,7 @@ export class AdMobPro extends IonicNativePlugin {
   @Cordova({
     eventObservable: true,
     event: 'onAdPresent',
-    element: document
+    element: 'document'
   })
   onAdPresent(): Observable<any> {
     return;
@@ -314,7 +314,7 @@ export class AdMobPro extends IonicNativePlugin {
   @Cordova({
     eventObservable: true,
     event: 'onAdLeaveApp',
-    element: document
+    element: 'document'
   })
   onAdLeaveApp(): Observable<any> {
     return;
@@ -327,7 +327,7 @@ export class AdMobPro extends IonicNativePlugin {
   @Cordova({
     eventObservable: true,
     event: 'onAdDismiss',
-    element: document
+    element: 'document'
   })
   onAdDismiss(): Observable<any> {
     return;

src/@ionic-native/plugins/admob/index.ts

@@ -0,0 +1,456 @@
+import { Injectable } from '@angular/core';
+import { Cordova, CordovaProperty, IonicNativePlugin, Plugin } from '@ionic-native/core';
+import { Observable } from 'rxjs';
+
+export interface AdmobOptions {
+  /**
+   * Your publisher id code from your AdMob account
+   */
+  publisherId: string;
+
+  /**
+   * (Optional) Your interstitial id code from your AdMob account. Defaults to publisherId
+   */
+  interstitialAdId?: string;
+
+  /**
+   * (Optional) Your rewarded id code from your AdMob account. Defaults to publisherId
+   */
+  rewardedAdId?: string;
+
+  /**
+   * (Optional) Your tappx id for iOS apps. If Admob is configured, it is also used to backfill your lost inventory when there are no Admob ads available
+   */
+  tappxIdiOS?: string;
+
+  /**
+   * (Optional) Your tappx id for Android apps. Admob is configured, it is also used to backfill your lost inventory when there are no Admob ads available
+   */
+  tappxIdAndroid?: string;
+
+  /**
+   * (Optional) If any of tappxId is present, it tells the percentage of traffic diverted to tappx. Defaults to 0.5 (50% of the traffic will be requested to Tappx)
+   */
+  tappxShare?: number;
+
+  /**
+   * (Optional) Indicates whether to put banner ads at top when set to true or at bottom when set to false. Defaults to false
+   */
+  bannerAtTop?: boolean;
+
+  /**
+   * (Optional) Indicates the size of banner ads
+   */
+  adSize?: string;
+
+  /**
+   * (Optional) Allow banner overlap webview. Default false
+   */
+  overlap?: boolean;
+
+  /**
+   * (Optional) Set to true to avoid ios7 status bar overlap. Default false
+   */
+  offsetStatusBar?: boolean;
+
+  /**
+   * (Optional) Set to true to receive test ads (do not test with real ads as your account may be banned). Defaults to false
+   */
+  isTesting?: boolean;
+
+  /**
+   * (Options) A JSON object with additional {key: value} pairs
+   */
+  adExtras?: any;
+
+  /**
+   * (Optional) Auto show banner ads when available (onAdLoaded event is called). Defaults to true
+   */
+  autoShowBanner?: boolean;
+
+  /**
+   * (Optional) Auto show interstitial asd when available (onAdLoaded event is called). Defaults to true
+   */
+  autoShowInterstitial?: boolean;
+
+  /**
+   * (Optional) Auto show rewarded ads when available (onAdLoaded event is called). Defaults to true
+   */
+  autoShowRewarded?: boolean;
+}
+
+/**
+ * @name Admob
+ * @description
+ * Most complete Admob plugin with support for [Tappx](http://www.tappx.com/?h=dec334d63287772de859bdb4e977fce6) ads.
+ * Monetize your apps and games with AdMob ads, using latest Google AdMob SDK. With this plugin you can show AdMob ads easily!
+ *
+ * **Supports:**
+ * - Banner ads (top and bottom)
+ * - Interstitial ads
+ * - Rewarded ads
+ * - [Tappx](http://www.tappx.com/?h=dec334d63287772de859bdb4e977fce6) ads
+ *
+ * @usage
+ * ```typescript
+ * import { Admob, AdmobOptions } from '@ionic-native/admob/ngx';
+ *
+ *
+ * constructor(private admob: Admob) {
+ *     // Admob options config
+ *     const admobOptions: AdmobOptions = {
+ *       publisherId: 'XXX-XXXX-XXXX',
+ *       interstitialAdId: 'XXX-XXXX-XXXX',
+ *       rewardedAdId: 'XXX-XXXX-XXXX',
+ *       isTesting: true,
+ *       autoShowBanner: false,
+ *       autoShowInterstitial: false,
+ *       autoShowRewarded: false,
+ *       adSize: this.admob.AD_SIZE.BANNER
+ *     };
+ *
+ *     // Set admob options
+ *     this.admob.setOptions(admobOptions)
+ *       .then(() => console.log('Admob options have been successfully set'))
+ *       .catch(err => console.error('Error setting admob options:', err));
+ * }
+ *
+ *
+ *
+ * // (Optionally) Load banner ad, in order to have it ready to show
+ * this.admob.createBannerView()
+ *   .then(() => console.log('Banner ad loaded'))
+ *   .catch(err => console.error('Error loading banner ad:', err));
+ *
+ *
+ * // Show banner ad (createBannerView must be called before and onAdLoaded() event raised)
+ * this.admob.onAdLoaded().subscribe((ad) => {
+ *   if (ad.adType === this.admob.AD_TYPE.BANNER) {
+ *     this.admob.showBannerAd()
+ *       .then(() => console.log('Banner ad shown'))
+ *       .catch(err => console.error('Error showing banner ad:', err));
+ *   }
+ * });
+ *
+ *
+ * // Hide banner ad, but do not destroy it, so it can be shown later on
+ * // See destroyBannerView in order to hide and destroy banner ad
+ * this.admob.showBannerAd(false)
+ *   .then(() => console.log('Banner ad hidden'))
+ *   .catch(err => console.error('Error hiding banner ad:', err));
+ *
+ *
+ *
+ * // Request an interstitial ad, in order to be shown later on
+ * // It is possible to autoshow it via options parameter, see docs
+ * this.admob.requestInterstitialAd()
+ *   .then(() => console.log('Interstitial ad loaded'))
+ *   .catch(err => console.error('Error loading interstitial ad:', err));
+ *
+ *
+ * // Show an interstitial ad (requestInterstitialAd must be called before)
+ * this.admob.onAdLoaded().subscribe((ad) => {
+ *   if (ad.adType === this.admob.AD_TYPE.INTERSTITIAL) {
+ *     this.admob.showInterstitialAd()
+ *       .then(() => console.log('Interstitial ad shown'))
+ *       .catch(err => console.error('Error showing interstitial ad:', err));
+ *   }
+ * });
+ *
+ *
+ * // Request a rewarded ad
+ * this.admob.requestRewardedAd()
+ *   .then(() => console.log('Rewarded ad loaded'))
+ *   .catch(err => console.error('Error loading rewarded ad:', err));
+ *
+ *
+ * // Show rewarded ad (requestRewardedAd must be called before)
+ * this.admob.onAdLoaded().subscribe((ad) => {
+ *   if (ad.adType === this.admob.AD_TYPE.REWARDED) {
+ *     this.admob.showRewardedAd()
+ *       .then(() => console.log('Rewarded ad shown'))
+ *       .catch(err => console.error('Error showing rewarded ad:', err));
+ *   }
+ * });
+ *
+ *
+ * // Hide and destroy banner or interstitial ad
+ * this.admob.destroyBannerView()
+ *   .then(() => console.log('Banner or interstitial ad destroyed'))
+ *   .catch(err => console.error('Error destroying banner or interstitial ad:', err));
+ *
+ *
+ *
+ * // On Ad loaded event
+ * this.admob.onAdLoaded().subscribe((ad) => {
+ *   if (ad.adType === this.admob.AD_TYPE.BANNER) {
+ *     console.log('Banner ad is loaded');
+ *     this.admob.showBannerAd();
+ *   } else if (ad.adType === this.admob.AD_TYPE.INTERSTITIAL) {
+ *     console.log('Interstitial ad is loaded');
+ *     this.admob.showInterstitialAd();
+ *   } else if (ad.adType === this.admob.AD_TYPE.REWARDED) {
+ *     console.log('Rewarded ad is loaded');
+ *     this.admob.showRewardedAd();
+ *   }
+ * });
+ *
+ *
+ *
+ * // On ad failed to load
+ * this.admob.onAdFailedToLoad().subscribe(err => console.log('Error loading ad:', err));
+ *
+ *
+ *
+ * // On interstitial ad opened
+ * this.admob.onAdOpened().subscribe(() => console.log('Interstitial ad opened'));
+ *
+ *
+ *
+ * // On interstitial ad closed
+ * this.admob.onAdClosed().subscribe(() => console.log('Interstitial ad closed'));
+ *
+ *
+ *
+ * // On ad clicked and left application
+ * this.admob.onAdLeftApplication().subscribe(() => console.log('Ad lefted application'));
+ *
+ *
+ *
+ * // On user ad rewarded
+ * this.admob.onRewardedAd().subscribe(() => console.log('The user has been rewarded'));
+ *
+ *
+ *
+ * // On rewarded ad video started
+ * this.admob.onRewardedAdVideoStarted().subscribe(() => console.log('Rewarded ad vieo started'));
+ *
+ *
+ *
+ * // On rewarded ad video completed
+ * this.admob.onRewardedAdVideoCompleted().subscribe(() => console.log('Rewarded ad video completed'));
+ *
+ * ```
+ */
+@Plugin({
+  pluginName: 'Admob',
+  plugin: 'cordova-admob',
+  pluginRef: 'admob',
+  repo: 'https://github.com/appfeel/admob-google-cordova',
+  platforms: ['Android', 'iOS']
+})
+@Injectable()
+export class Admob extends IonicNativePlugin {
+  /**
+   * This enum represents AdMob's supported ad sizes.
+   * Use one of these constants as adSize option when calling createBannerView
+   * @readonly
+   */
+  @CordovaProperty()
+  readonly AD_SIZE: {
+    BANNER: string;
+    IAB_MRECT: string;
+    IAB_BANNER: string;
+    IAB_LEADERBOARD: string;
+    SMART_BANNER: string;
+  };
+
+  /**
+   * This enum represents AdMob's supported ad types
+   * @readonly
+   */
+  @CordovaProperty()
+  readonly AD_TYPE: {
+    BANNER: string;
+    INTERSTITIAL: string;
+    REWARDED: string;
+  };
+
+  /**
+   * Set the options to start displaying ads.
+   * Although it is not required to call this method, as options can be specified in other methods, it is highly recommended
+   * @param options {AdmobOptions} Some param to configure something
+   * @return {Promise<any>} Returns a promise that resolves when the options are set
+   */
+  @Cordova()
+  setOptions(options: AdmobOptions): Promise<any> {
+    return;
+  }
+
+  /**
+   * Creates a new banner ad view. Call this method in order to be able to start showing banners
+   * @param options {AdmobOptions} (Optional) Setup options
+   * @return {Promise<any>} Returns a promise that resolves when the banner view is created
+   */
+  @Cordova()
+  createBannerView(options?: AdmobOptions): Promise<any> {
+    return;
+  }
+
+  /**
+   * Show banner ads. You must call createBannerView first, otherwise it will result in failure callback and no ads will be shown
+   * @param show {boolean} (Optional) Indicates whether to show or hide banner ads. Defaults to `true`
+   * @return {Promise<any>} Returns a promise that resolves when the banner shown or hidden
+   */
+  @Cordova()
+  showBannerAd(show?: boolean): Promise<any> {
+    return;
+  }
+
+  /**
+   * Hide and destroy banner view. Call this method when you want to destroy banner view.
+   * It is not necessary to call this method when the app closed, as it will be automatically called by the plugin
+   */
+  @Cordova()
+  destroyBannerView() {}
+
+  /**
+   * Request an interstitial ad
+   * If `options.autoShowInterstitial` is set to `true` (default), the ad will automatically be displayed.
+   * Otherwise you need to subscribe to `onAdLoaded()` event and call `showInterstitialAd()` after it will be raised specifying that an interstitial ad is available.
+   * If you already called `requestInterstitialAd()` but the interstitial has never been shown, the successive calls to `requestInterstitialAd()` will result in the ad being inmediately available (the one that was obtained on the first call)
+   * @param options {AdmobOptions} (Optional) Setup options
+   * @return {Promise<any>} Returns a promise that resolves when the interstitial ad is loaded
+   */
+  @Cordova()
+  requestInterstitialAd(options?: AdmobOptions): Promise<any> {
+    return;
+  }
+
+  /**
+   * Show an interstitial ad. Call it after `requestInterstitialAd()` and `onAdLoaded()` event raised.
+   * @return {Promise<any>} Returns a promise that resolves when the interstitial ad is shown
+   */
+  @Cordova()
+  showInterstitialAd(): Promise<any> {
+    return;
+  }
+
+  /**
+   * Request an rewarded ad
+   * If `options.autoShowRewarded` is set to `true` (default), the ad will automatically be displayed.
+   * Otherwise you need to subscribe to `onAdLoaded()` enent and call `showRewardedAd()` after it will be raised specifying that a rewarded ad is available.
+   * If you already called `requestRewardedAd()` but the rewarded has never been shown, the successive calls to `requestRewardedAd()` will result in the ad being inmediately available (the one that was obtained on the first call)
+   * @param options {AdmobOptions} (Optional) Setup options
+   * @return {Promise<any>} Returns a promise that resolves when the rewarded ad is loaded
+   */
+  @Cordova()
+  requestRewardedAd(options?: AdmobOptions): Promise<any> {
+    return;
+  }
+
+  /**
+   * Show a rewarded ad
+   * @return {Promise<any>} Returns a promise that resolves when the rewarded ad is shown
+   */
+  @Cordova()
+  showRewardedAd(): Promise<any> {
+    return;
+  }
+
+  /**
+   * Called when an ad is received
+   * @returns {Observable<any>} Returns an observable when an ad is received
+   */
+  @Cordova({
+    eventObservable: true,
+    event: 'appfeel.cordova.admob.onAdLoaded',
+    element: document
+  })
+  onAdLoaded(): Observable<any> {
+    return;
+  }
+
+  /**
+   * Called when an ad request failed
+   * @returns {Observable<any>} Returns an observable when an ad request is failed
+   */
+  @Cordova({
+    eventObservable: true,
+    event: 'appfeel.cordova.admob.onAdFailedToLoad',
+    element: document
+  })
+  onAdFailedToLoad(): Observable<any> {
+    return;
+  }
+
+  /**
+   * Called when an ad opens an overlay that covers the screen.
+   * Please note that onPause cordova event is raised when an interstitial is shown
+   * @returns {Observable<any>} Returns an observable when an ad is opened
+   */
+  @Cordova({
+    eventObservable: true,
+    event: 'appfeel.cordova.admob.onAdOpened',
+    element: document
+  })
+  onAdOpened(): Observable<any> {
+    return;
+  }
+
+  /**
+   * Called when the user is about to return to the application after clicking on an ad.
+   * Please note that onResume cordova event is raised when an interstitial is closed
+   * @returns {Observable<any>} Returns an observable when an ad is closed
+   */
+  @Cordova({
+    eventObservable: true,
+    event: 'appfeel.cordova.admob.onAdClosed',
+    element: document
+  })
+  onAdClosed(): Observable<any> {
+    return;
+  }
+
+  /**
+   * Called when the user leaves the application after clicking an ad (e.g., to go to the browser)
+   * @returns {Observable<any>} Returns an observable when an ad leaves the application
+   */
+  @Cordova({
+    eventObservable: true,
+    event: 'appfeel.cordova.admob.onAdLeftApplication',
+    element: document
+  })
+  onAdLeftApplication(): Observable<any> {
+    return;
+  }
+
+  /**
+   * Called when the user has been rewarded by an ad
+   * @returns {Observable<any>} Returns an observable when the user rewards an ad
+   */
+  @Cordova({
+    eventObservable: true,
+    event: 'appfeel.cordova.admob.onRewardedAd',
+    element: document
+  })
+  onRewardedAd(): Observable<any> {
+    return;
+  }
+
+  /**
+   * Called when the video of a rewarded ad started
+   * @returns {Observable<any>} Returns an observable when the video is started
+   */
+  @Cordova({
+    eventObservable: true,
+    event: 'appfeel.cordova.admob.onRewardedAdVideoStarted',
+    element: document
+  })
+  onRewardedAdVideoStarted(): Observable<any> {
+    return;
+  }
+
+  /**
+   * Called when the video of a rewarded ad has completed
+   * @returns {Observable<any>} Returns an observable when the video is completed
+   */
+  @Cordova({
+    eventObservable: true,
+    event: 'appfeel.cordova.admob.onRewardedAdVideoCompleted',
+    element: document
+  })
+  onRewardedAdVideoCompleted(): Observable<any> {
+    return;
+  }
+}

src/@ionic-native/plugins/aes-256/index.ts

@@ -0,0 +1,105 @@
+import { Injectable } from '@angular/core';
+import { Cordova, IonicNativePlugin, Plugin } from '@ionic-native/core';
+
+/**
+ * @name AES256
+ * @description
+ * This cordova ionic plugin allows you to perform AES 256 encryption and decryption on the plain text.
+ * It's a cross-platform plugin which supports both Android and iOS.
+ * The encryption and decryption are performed on the device native layer so that the performance is much faster.
+ *
+ * @usage
+ * ```typescript
+ * import { AES256 } from '@ionic-native/aes-256/ngx';
+ *
+ * private secureKey: string;
+ * private secureIV: string;
+ *
+ * constructor(private aes256: AES256) {
+ *    this.generateSecureKeyAndIV(); // To generate the random secureKey and secureIV
+ * }
+ *
+ * ...
+ *
+ * async generateSecureKeyAndIV() {
+ *    this.secureKey = await this.aes256.generateSecureKey('random password 12345'); // Returns a 32 bytes string
+ *    this.secureIV = await this.aes256.generateSecureIV('random password 12345'); // Returns a 16 bytes string
+ * }
+ *
+ * this.aes256.encrypt(this.secureKey, this.secureIV, 'testdata')
+ *   .then(res => console.log('Encrypted Data: ',res))
+ *   .catch((error: any) => console.error(error));
+ *
+ * this.aes256.decrypt(this.secureKey, this.secureIV, 'encryptedData')
+ *   .then(res => console.log('Decrypted Data : ',res))
+ *   .catch((error: any) => console.error(error));
+ *
+ *
+ * * this.aes256.generateSecureKey('random password 12345')
+ *   .then(res => console.log('Secure Key : ',res))
+ *   .catch((error: any) => console.error(error));
+ *
+ *
+ * * this.aes256.generateSecureIV('random password 12345')
+ *   .then(res => console.log('Secure IV : ',res))
+ *   .catch((error: any) => console.error(error));
+ *
+ * ```
+ */
+@Plugin({
+  pluginName: 'AES256',
+  plugin: 'cordova-plugin-aes256-encryption',
+  pluginRef: 'cordova.plugins.AES256',
+  repo: 'https://github.com/Ideas2IT/cordova-aes256',
+  platforms: ['Android', 'iOS'],
+  install: 'ionic cordova plugin add cordova-plugin-aes256-encryption'
+})
+@Injectable()
+export class AES256 extends IonicNativePlugin {
+  /**
+   * This function used to perform the aes256 encryption
+   * @param {string} secureKey A 32 bytes string, which will used as input key for AES256 encryption.
+   * @param {string} secureIV A 16 bytes string, which will used as initial vector for AES256 encryption.
+   * @param {string} data A string which will be encrypted
+   * @return {Promise<string>} Returns a promise that resolves when encryption happens. The success response will returns encrypted data.
+   */
+  @Cordova()
+  encrypt(secureKey: string, secureIV: string, data: string): Promise<string> {
+    return;
+  }
+
+  /**
+   * This function used to perform the aes256 decryption
+   * @param {string} secureKey A 32 bytes string, which will used as input key for AES256 decryption.
+   * @param {string} secureIV A 16 bytes string, which will used as initial vector for AES256 decryption.
+   * @param {string} data An AES256 encrypted data which will be decrypted.
+   * @return {Promise<string>} Returns a promise that resolves when decryption happens. The success response will returns decrypted data.
+   */
+  @Cordova()
+  decrypt(secureKey: string, secureIV: string, data: string): Promise<string> {
+    return;
+  }
+
+  /**
+   * This function used to generate a secure key based on an password. Perfect if you want to delegate the key generation for encryption to the plugin.
+   * Make sure to save the return value of this function somewhere so your encrypted data can be decrypted in the future.
+   * @param {string} password A random string, which will be used as input for a PBKDF2 function
+   * @return {Promise<string>} Returns a promise that resolves when key is generated.
+   */
+  @Cordova()
+  generateSecureKey(password: string): Promise<string> {
+    return;
+  }
+
+  /**
+   * This function used to generate a secure IV based on an password. Perfect if you want to delegate the IV generation for encryption to the plugin.
+   * Make sure to save the return value of this function somewhere so your encrypted data can be decrypted in the future.
+   * @param {string} password A random string, which will be used as input for a PBKDF2 function
+   * @return {Promise<string>} Returns a promise that resolves when IV is generated.
+   */
+  @Cordova()
+  generateSecureIV(password: string): Promise<string> {
+    return;
+  }
+
+}

src/@ionic-native/plugins/alipay/index.ts

@@ -1,84 +1,21 @@
 import { Injectable } from '@angular/core';
 import { Cordova, IonicNativePlugin, Plugin } from '@ionic-native/core';
 
-export interface AlipayOrder {
-  /**
-   * appId assigned by Alipay
-   */
-  app_id: string;
-
-  /**
-   * Api name.
-   * Should be: alipay.trade.app.pay
-   */
-  method: string;
-
-  /**
-   * Data format
-   * Default: "JSON"
-   */
-  format?: string;
-
-  /**
-   * Charset
-   * Possible values: "UTF-8", "GBK"
-   * Default: "UTF-8"
-   */
-  charset: string;
-
-  /**
-   * Sign method
-   * Default: 'RSA'
-   */
-  sign_type: string;
-
-  /**
-   * Sign value. Should be got from server side.
-   * Default: 'RSA'
-   */
-  sign: string;
-
-  /**
-   * Timestamp, formated like "yyyy-MM-dd HH:mm:ss", e.g. 2014-07-24 03:07:50
-   */
-  timestamp: string;
-
-  /**
-   * Api version. Fixed value '1.0'
-   */
-  version: string;
-
-  /**
-   * Notify url.
-   */
-  notify_url: string;
-
-  /**
-   * biz content. formated in json. see alipay doc for detail.
-   */
-  biz_content: string;
-}
-
 /**
  * @name Alipay
  * @description
- * This plugin is used for Alipay APP support. Integrated with the latest SDK.
+ * This plugin facilitates the usage of Alipay 支付宝 in an Ionic apps with the integrated AlipaySDK dated on 20180601.
  *
- * Requires Cordova plugin: `cordova-alipay-base`. For more info, please see the [Alipay plugin docs](https://github.com/xueron/cordova-alipay-base).
+ * Requires Cordova plugin: `cordova-plugin-gubnoi-alipay`. For more info, please see https://github.com/jing-zhou/cordova-plugin-alipay .
  *
  * @usage
  * ```typescript
- * import { Alipay, AlipayOrder } from '@ionic-native/alipay';
+ * import { Alipay } from '@ionic-native/alipay/ngx';
  *
  * constructor(private alipay: Alipay) {
  *
- * // Should get from server side with sign.
- * const alipayOrder: AlipayOrder = {
- *       ...
- *     };
- *
- *
- * this.alipay.pay(alipayOrder)
+ * //alipayOrder is a string that has been generated and signed by the server side.
+ * this.alipay.pay(alipayOrder, success, error)
  *    .then(result => {
  *       console.log(result); // Success
  *    })
@@ -88,31 +25,26 @@ export interface AlipayOrder {
  *
  * }
  *
- *
  * ```
- *
- * @interfaces
- * AlipayOrder
  */
 @Plugin({
   pluginName: 'Alipay',
-  plugin: 'cordova-alipay-base',
-  pluginRef: 'Alipay.Base',
-  repo: 'https://github.com/xueron/cordova-alipay-base',
-  install:
-    'ionic cordova plugin add cordova-alipay-base --variable ALI_PID=your_app_id',
-  installVariables: ['ALI_PID'],
+  plugin: 'cordova-plugin-gubnoi-alipay',
+  pluginRef: 'cordova.plugins.alipay',
+  repo: 'https://github.com/jing-zhou/cordova-plugin-alipay',
+  install: 'ionic cordova plugin add cordova-plugin-gubnoi-alipay --variable APP_ID=your_app_id',
+  installVariables: ['APP_ID'],
   platforms: ['Android', 'iOS']
 })
 @Injectable()
 export class Alipay extends IonicNativePlugin {
   /**
    * Open Alipay to perform App pay
-   * @param { AlipayOrder | string } order alipay options
+   * @param {string} order alipay order string
    * @returns {Promise<any>} Returns a Promise that resolves with the success return, or rejects with an error.
    */
   @Cordova()
-  pay(order: AlipayOrder | string): Promise<any> {
+  pay(order: string, success?: (res?: any) => void, error?: (err?: any) => void): Promise<any> {
     return;
   }
 }

src/@ionic-native/plugins/analytics-firebase/index.ts

@@ -0,0 +1,248 @@
+import { Injectable } from '@angular/core';
+import { Cordova, CordovaProperty, IonicNativePlugin, Plugin } from '@ionic-native/core';
+
+/**
+ * @name Analytics Firebase
+ * @description
+ * Google Analytics Firebase plugin for Ionic Native apps.
+ *
+ * @usage
+ * ```typescript
+ * import { AnalyticsFirebase } from '@ionic-native/analytics-firebase';
+ *
+ *
+ * constructor(private analyticsFirebase: AnalyticsFirebase) { }
+ *
+ * // Track an event with default events and params
+ * const eventParams = {};
+ * eventParams[this.analyticsFirebase.DEFAULT_PARAMS.LEVEL] = 29;
+ * this.analyticsFirebase.logEvent(this.analyticsFirebase.DEFAULT_EVENTS.LEVEL_UP, eventParams)
+ *   .then(() => console.log('Event successfully tracked'))
+ *   .catch(err => console.log('Error tracking event:', err));
+ *
+ * // Track an event with custom events and params
+ * const eventParams = {};
+ * eventParams['my-prop'] = 29;
+ * this.analyticsFirebase.logEvent('my-event', eventParams)
+ *   .then(() => console.log('Event successfully tracked'))
+ *   .catch(err => console.log('Error tracking event:', err));
+ *
+ *
+ * // Reset analytics data
+ * this.analyticsFirebase.resetAnalyticsData()
+ *   .then(() => console.log('Analytics data have been reset'))
+ *   .catch(err => console.log('Error resetting analytics data:', err));
+ *
+ *
+ * // Track a screen view
+ * this.analyticsFirebase.setCurrentScreen('Home')
+ *   .then(() => console.log('View successfully tracked'))
+ *   .catch(err => console.log('Error tracking view:', err));
+ *
+ *
+ * // Set user id
+ * this.analyticsFirebase.setUserId('USER-ID')
+ *   .then(() => console.log('User id successfully set'))
+ *   .catch(err => console.log('Error setting user id:', err));
+ *
+ *
+ * // Set user property from default properties
+ * this.analyticsFirebase.setUserProperty('KEY', 'VALUE')
+ *   .then(() => console.log('User property successfully set'))
+ *   .catch(err => console.log('Error setting user property:', err));
+ *
+ * ```
+ */
+@Plugin({
+  pluginName: 'AnalyticsFirebase',
+  plugin: 'cordova-plugin-analytics',
+  pluginRef: 'analytics',
+  repo: 'https://github.com/appfeel/analytics-google',
+  platforms: ['Android', 'iOS']
+})
+@Injectable()
+export class AnalyticsFirebase extends IonicNativePlugin {
+  /**
+   * This enum represents AnalyticsFirebase default events.
+   * Use one of these default events or a custom event
+   * @readonly
+   */
+  @CordovaProperty()
+  readonly DEFAULT_EVENTS: {
+    ADD_PAYMENT_INFO: string;
+    ADD_TO_CART: string;
+    ADD_TO_WISHLIST: string;
+    APP_OPEN: string;
+    BEGIN_CHECKOUT: string;
+    CAMPAIGN_DETAILS: string;
+    CHECKOUT_PROGRESS: string;
+    EARN_VIRTUAL_CURRENCY: string;
+    ECOMMERCE_PURCHASE: string;
+    GENERATE_LEAD: string;
+    JOIN_GROUP: string;
+    LEVEL_END: string;
+    LEVEL_START: string;
+    LEVEL_UP: string;
+    LOGIN: string;
+    POST_SCORE: string;
+    PRESENT_OFFER: string;
+    PURCHASE_REFUND: string;
+    REMOVE_FROM_CART: string;
+    SEARCH: string;
+    SELECT_CONTENT: string;
+    SET_CHECKOUT_OPTION: string;
+    SHARE: string;
+    SIGN_UP: string;
+    SPEND_VIRTUAL_CURRENCY: string;
+    TUTORIAL_BEGIN: string;
+    TUTORIAL_COMPLETE: string;
+    UNLOCK_ACHIEVEMENT: string;
+    VIEW_ITEM: string;
+    VIEW_ITEM_LIST: string;
+    VIEW_SEARCH_RESULTS: string;
+  };
+
+  /**
+   * This enum represents AnalyticsFirebase default params.
+   * Use one of these default params or a custom param
+   * @readonly
+   */
+  @CordovaProperty()
+  readonly DEFAULT_PARAMS: {
+    ACHIEVEMENT_ID: string;
+    ACLID: string;
+    AFFILIATION: string;
+    CAMPAIGN: string;
+    CHARACTER: string;
+    CHECKOUT_OPTION: string;
+    CHECKOUT_STEP: string;
+    CONTENT: string;
+    CONTENT_TYPE: string;
+    COUPON: string;
+    CP1: string;
+    CREATIVE_NAME: string;
+    CREATIVE_SLOT: string;
+    CURRENCY: string;
+    DESTINATION: string;
+    END_DATE: string;
+    FLIGHT_NUMBER: string;
+    GROUP_ID: string;
+    INDEX: string;
+    ITEM_BRAND: string;
+    ITEM_CATEGORY: string;
+    ITEM_ID: string;
+    ITEM_LIST: string;
+    ITEM_LOCATION_ID: string;
+    ITEM_NAME: string;
+    ITEM_VARIANT: string;
+    LEVEL: string;
+    LEVEL_NAME: string;
+    LOCATION: string;
+    MEDIUM: string;
+    METHOD: string;
+    NUMBER_OF_NIGHTS: string;
+    NUMBER_OF_PASSENGERS: string;
+    NUMBER_OF_ROOMS: string;
+    ORIGIN: string;
+    PRICE: string;
+    QUANTITY: string;
+    SCORE: string;
+    SEARCH_TERM: string;
+    SHIPPING: string;
+    SOURCE: string;
+    START_DATE: string;
+    SUCCESS: string;
+    TAX: string;
+    TERM: string;
+    TRANSACTION_ID: string;
+    TRAVEL_CLASS: string;
+    VALUE: string;
+    VIRTUAL_CURRENCY_NAME: string;
+  };
+
+  /**
+   * Logs an app event. The event can have up to 25 parameters.
+   * Events with the same name must have the same parameters.
+   * Up to 500 event names are supported.
+   * Using predefined [FirebaseAnalytics.Event](https://firebase.google.com/docs/reference/android/com/google/firebase/analytics/FirebaseAnalytics.Event.html) and/or [FirebaseAnalytics.Param](https://firebase.google.com/docs/reference/android/com/google/firebase/analytics/FirebaseAnalytics.Param.html) is recommended for optimal reporting.
+   *
+   * @param eventName {string} The event name
+   * @param eventParams {object} (Optional) The event params
+   * @return {Promise<any>} Returns a promise that resolves when the event is logged
+   */
+  @Cordova()
+  logEvent(eventName: string, eventParams?: object): Promise<any> {
+    return;
+  }
+
+  /**
+   * Clears all analytics data for this app from the device and resets the app instance id
+   * @return {Promise<any>} Returns a promise that resolves when the analytics data is cleared
+   */
+  @Cordova()
+  resetAnalyticsData(): Promise<any> {
+    return;
+  }
+
+  /**
+   * Sets whether analytics collection is enabled for this app on this device. This setting is persisted across app sessions. By default it is enabled
+   * @param screenName {boolean} The value of the collection
+   * @return {Promise<any>} Returns a promise that resolves when the collection is enabled/disabled
+   */
+  @Cordova()
+  setAnalyticsCollectionEnabled(enabled: boolean): Promise<any> {
+    return;
+  }
+
+  /**
+   * Sets the current screen name, which specifies the current visual context in your app.
+   * This helps identify the areas in your app where users spend their time and how they interact with your app
+   * @param screenName {string} The screen name
+   * @return {Promise<any>} Returns a promise that resolves when the current screen is setted
+   */
+  @Cordova()
+  setCurrentScreen(screenName: string): Promise<any> {
+    return;
+  }
+
+  /**
+   * Sets the minimum engagement time required before starting a session. The default value is 10000 (10 seconds)
+   * @param screenName {number} The duration in milliseconds
+   * @return {Promise<any>} Returns a promise that resolves when the minimum session duration is set
+   */
+  @Cordova()
+  setMinimumSessionDuration(milliseconds: number): Promise<any> {
+    return;
+  }
+
+  /**
+   * Sets the duration of inactivity that terminates the current session. The default value is 1800000 (30 minutes)
+   * @param screenName {number} The duration in milliseconds
+   * @return {Promise<any>} Returns a promise that resolves when the session timeout duration is set
+   */
+  @Cordova()
+  setSessionTimeoutDuration(milliseconds: number): Promise<any> {
+    return;
+  }
+
+  /**
+   * Sets the user ID property. This feature must be used in accordance with Google's Privacy Policy
+   * @param userId {string} The user id
+   * @return {Promise<any>} Returns a promise that resolves when the user id is setted
+   */
+  @Cordova()
+  setUserId(userId: string): Promise<any> {
+    return;
+  }
+
+  /**
+   * Sets a user property to a given value. Up to 25 user property names are supported. Once set, user property values persist throughout the app lifecycle and across sessions
+   * @param userPropertyName {string} The user property name
+   * @param userPropertyValue {string} The user property value
+   * @return {Promise<any>} Returns a promise that resolves when the user property setted
+   */
+  @Cordova()
+  setUserProperty(userPropertyName: string, userPropertyValue: string): Promise<any> {
+    return;
+  }
+}

src/@ionic-native/plugins/android-exoplayer/index.ts

@@ -1,6 +1,6 @@
 import { Injectable } from '@angular/core';
 import { Cordova, IonicNativePlugin, Plugin } from '@ionic-native/core';
-import { Observable } from 'rxjs/Observable';
+import { Observable } from 'rxjs';
 
 export type AndroidExoPlayerAspectRatio = 'FILL_SCREEN' | 'FIT_SCREEN';
 
@@ -158,7 +158,7 @@ export interface AndroidExoPlayerControllerConfig {
  *
  * @usage
  * ```typescript
- * import { AndroidExoPlayer } from '@ionic-native/android-exoplayer';
+ * import { AndroidExoPlayer } from '@ionic-native/android-exoplayer/ngx';
  *
  * constructor(private androidExoPlayer: AndroidExoPlayer) { }
  *

src/@ionic-native/plugins/android-fingerprint-auth/index.ts

@@ -110,7 +110,7 @@ export interface AFADeleteOptions {
  * This plugin will open a native dialog fragment prompting the user to authenticate using their fingerprint. If the device has a secure lockscreen (pattern, PIN, or password), the user may opt to authenticate using that method as a backup.
  * @usage
  * ```typescript
- * import { AndroidFingerprintAuth } from '@ionic-native/android-fingerprint-auth';
+ * import { AndroidFingerprintAuth } from '@ionic-native/android-fingerprint-auth/ngx';
  *
  * constructor(private androidFingerprintAuth: AndroidFingerprintAuth) { }
  *
@@ -159,25 +159,47 @@ export interface AFADeleteOptions {
 })
 @Injectable()
 export class AndroidFingerprintAuth extends IonicNativePlugin {
+  /**
+   * Convenience property containing all possible errors
+   */
   ERRORS: {
-    BAD_PADDING_EXCEPTION: 'BAD_PADDING_EXCEPTION';
-    CERTIFICATE_EXCEPTION: 'CERTIFICATE_EXCEPTION';
-    FINGERPRINT_CANCELLED: 'FINGERPRINT_CANCELLED';
-    FINGERPRINT_DATA_NOT_DELETED: 'FINGERPRINT_DATA_NOT_DELETED';
-    FINGERPRINT_ERROR: 'FINGERPRINT_ERROR';
-    FINGERPRINT_NOT_AVAILABLE: 'FINGERPRINT_NOT_AVAILABLE';
-    FINGERPRINT_PERMISSION_DENIED: 'FINGERPRINT_PERMISSION_DENIED';
-    FINGERPRINT_PERMISSION_DENIED_SHOW_REQUEST: 'FINGERPRINT_PERMISSION_DENIED_SHOW_REQUEST';
-    ILLEGAL_BLOCK_SIZE_EXCEPTION: 'ILLEGAL_BLOCK_SIZE_EXCEPTION';
-    INIT_CIPHER_FAILED: 'INIT_CIPHER_FAILED';
-    INVALID_ALGORITHM_PARAMETER_EXCEPTION: 'INVALID_ALGORITHM_PARAMETER_EXCEPTION';
-    IO_EXCEPTION: 'IO_EXCEPTION';
-    JSON_EXCEPTION: 'JSON_EXCEPTION';
-    MINIMUM_SDK: 'MINIMUM_SDK';
-    MISSING_ACTION_PARAMETERS: 'MISSING_ACTION_PARAMETERS';
-    MISSING_PARAMETERS: 'MISSING_PARAMETERS';
-    NO_SUCH_ALGORITHM_EXCEPTION: 'NO_SUCH_ALGORITHM_EXCEPTION';
-    SECURITY_EXCEPTION: 'SECURITY_EXCEPTION';
+    BAD_PADDING_EXCEPTION: string;
+    CERTIFICATE_EXCEPTION: string;
+    FINGERPRINT_CANCELLED: string;
+    FINGERPRINT_DATA_NOT_DELETED: string;
+    FINGERPRINT_ERROR: string;
+    FINGERPRINT_NOT_AVAILABLE: string;
+    FINGERPRINT_PERMISSION_DENIED: string;
+    FINGERPRINT_PERMISSION_DENIED_SHOW_REQUEST: string;
+    ILLEGAL_BLOCK_SIZE_EXCEPTION: string;
+    INIT_CIPHER_FAILED: string;
+    INVALID_ALGORITHM_PARAMETER_EXCEPTION: string;
+    IO_EXCEPTION: string;
+    JSON_EXCEPTION: string;
+    MINIMUM_SDK: string;
+    MISSING_ACTION_PARAMETERS: string;
+    MISSING_PARAMETERS: string;
+    NO_SUCH_ALGORITHM_EXCEPTION: string;
+    SECURITY_EXCEPTION: string;
+  } = {
+    BAD_PADDING_EXCEPTION: 'BAD_PADDING_EXCEPTION',
+    CERTIFICATE_EXCEPTION: 'CERTIFICATE_EXCEPTION',
+    FINGERPRINT_CANCELLED: 'FINGERPRINT_CANCELLED',
+    FINGERPRINT_DATA_NOT_DELETED: 'FINGERPRINT_DATA_NOT_DELETED',
+    FINGERPRINT_ERROR: 'FINGERPRINT_ERROR',
+    FINGERPRINT_NOT_AVAILABLE: 'FINGERPRINT_NOT_AVAILABLE',
+    FINGERPRINT_PERMISSION_DENIED: 'FINGERPRINT_PERMISSION_DENIED',
+    FINGERPRINT_PERMISSION_DENIED_SHOW_REQUEST: 'FINGERPRINT_PERMISSION_DENIED_SHOW_REQUEST',
+    ILLEGAL_BLOCK_SIZE_EXCEPTION: 'ILLEGAL_BLOCK_SIZE_EXCEPTION',
+    INIT_CIPHER_FAILED: 'INIT_CIPHER_FAILED',
+    INVALID_ALGORITHM_PARAMETER_EXCEPTION: 'INVALID_ALGORITHM_PARAMETER_EXCEPTION',
+    IO_EXCEPTION: 'IO_EXCEPTION',
+    JSON_EXCEPTION: 'JSON_EXCEPTION',
+    MINIMUM_SDK: 'MINIMUM_SDK',
+    MISSING_ACTION_PARAMETERS: 'MISSING_ACTION_PARAMETERS',
+    MISSING_PARAMETERS: 'MISSING_PARAMETERS',
+    NO_SUCH_ALGORITHM_EXCEPTION: 'NO_SUCH_ALGORITHM_EXCEPTION',
+    SECURITY_EXCEPTION: 'SECURITY_EXCEPTION'
   };
 
   /**

src/@ionic-native/plugins/android-full-screen/index.ts

@@ -1,9 +1,9 @@
 import { Injectable } from '@angular/core';
-import { Cordova, Plugin, IonicNativePlugin } from '@ionic-native/core';
+import { Cordova, IonicNativePlugin, Plugin } from '@ionic-native/core';
 
 /**
  * Bit flag values for setSystemUiVisibility()
- * @see	https://developer.android.com/reference/android/view/View.html#setSystemUiVisibility(int)
+ * @see  https://developer.android.com/reference/android/view/View.html#setSystemUiVisibility(int)
  */
 export enum AndroidSystemUiFlags {
   /** View has requested the system UI (status bar) to be visible (the default). SYSTEM_UI_FLAG_VISIBLE */
@@ -36,7 +36,7 @@ export enum AndroidSystemUiFlags {
  * In Android 4.4+, however, you can now enter true full screen, fully interactive immersive mode. In this mode, your app will remain in true full screen until you choose otherwise; users can swipe down from the top of the screen to temporarily display the system UI.
  * @usage
  * ```typescript
- * import { AndroidFullScreen } from '@ionic-native/android-full-screen';
+ * import { AndroidFullScreen } from '@ionic-native/android-full-screen/ngx';
  *
  * constructor(private androidFullScreen: AndroidFullScreen) { }
  *
@@ -44,7 +44,7 @@ export enum AndroidSystemUiFlags {
  *
  * this.androidFullScreen.isImmersiveModeSupported()
  *   .then(() => console.log('Immersive mode supported'))
- *   .catch(err => console.log(error));
+ *   .catch(err => console.log(err));
  *
  * ```
  */
@@ -62,63 +62,81 @@ export class AndroidFullScreen extends IonicNativePlugin {
    * @return {Promise<void>}
    */
   @Cordova()
-  isSupported(): Promise<void> { return; }
+  isSupported(): Promise<void> {
+    return;
+  }
 
   /**
    * Is immersive mode supported?
    * @return {Promise<void>}
    */
   @Cordova()
-  isImmersiveModeSupported(): Promise<void> { return; }
+  isImmersiveModeSupported(): Promise<void> {
+    return;
+  }
 
   /**
    * The width of the screen in immersive mode.
    * @return {Promise<number>}
    */
   @Cordova()
-  immersiveWidth(): Promise<number> { return; }
+  immersiveWidth(): Promise<number> {
+    return;
+  }
 
   /**
    * The height of the screen in immersive mode.
    * @return {Promise<number>}
    */
   @Cordova()
-  immersiveHeight(): Promise<number> { return; }
+  immersiveHeight(): Promise<number> {
+    return;
+  }
 
   /**
    * Hide system UI until user interacts.
    * @return {Promise<void>}
    */
   @Cordova()
-  leanMode(): Promise<void> { return; }
+  leanMode(): Promise<void> {
+    return;
+  }
 
   /**
    * Show system UI.
    * @return {Promise<void>}
    */
   @Cordova()
-  showSystemUI(): Promise<void> { return; }
+  showSystemUI(): Promise<void> {
+    return;
+  }
 
   /**
    * Extend your app underneath the status bar (Android 4.4+ only).
    * @return {Promise<void>}
    */
   @Cordova()
-  showUnderStatusBar(): Promise<void> { return; }
+  showUnderStatusBar(): Promise<void> {
+    return;
+  }
 
   /**
    * Extend your app underneath the system UI (Android 4.4+ only).
    * @return {Promise<void>}
    */
   @Cordova()
-  showUnderSystemUI(): Promise<void> { return; }
+  showUnderSystemUI(): Promise<void> {
+    return;
+  }
 
   /**
    * Hide system UI and keep it hidden (Android 4.4+ only).
    * @return {Promise<void>}
    */
   @Cordova()
-  immersiveMode(): Promise<void> { return; }
+  immersiveMode(): Promise<void> {
+    return;
+  }
 
   /**
    * Manually set the the system UI to a custom mode. This mirrors the Android method of the same name. (Android 4.4+ only).
@@ -127,5 +145,7 @@ export class AndroidFullScreen extends IonicNativePlugin {
    * @return {Promise<void>}
    */
   @Cordova()
-  setSystemUiVisibility(visibility: AndroidSystemUiFlags): Promise<void> { return; }
+  setSystemUiVisibility(visibility: AndroidSystemUiFlags): Promise<void> {
+    return;
+  }
 }

src/@ionic-native/plugins/android-permissions/index.ts

@@ -10,7 +10,7 @@ import { Cordova, IonicNativePlugin, Plugin } from '@ionic-native/core';
  *
  * @usage
  * ```
- * import { AndroidPermissions } from '@ionic-native/android-permissions';
+ * import { AndroidPermissions } from '@ionic-native/android-permissions/ngx';
  *
  *
  * constructor(private androidPermissions: AndroidPermissions) { }
@@ -204,26 +204,26 @@ export class AndroidPermissions extends IonicNativePlugin {
   /**
    * Check permission
    * @param {string} permission The name of the permission
-   * @return {Promise<any>} Returns a promise
+   * @return {Promise<AndroidPermissionResponse>} Returns a promise
    */
   @Cordova()
-  checkPermission(permission: string): Promise<any> {
+  checkPermission(permission: string): Promise<AndroidPermissionResponse> {
     return;
   }
 
   /**
    * Request permission
    * @param {string} permission The name of the permission to request
-   * @return {Promise<any>}
+   * @return {Promise<AndroidPermissionResponse>}
    */
   @Cordova()
-  requestPermission(permission: string): Promise<any> {
+  requestPermission(permission: string): Promise<AndroidPermissionResponse> {
     return;
   }
 
   /**
    * Request permissions
-   * @param {Array<string>} permissions An array with permissions
+   * @param {string[]} permissions An array with permissions
    * @return {Promise<any>} Returns a promise
    */
   @Cordova()
@@ -234,10 +234,14 @@ export class AndroidPermissions extends IonicNativePlugin {
   /**
    * This function still works now, will not support in the future.
    * @param {string} permission The name of the permission
-   * @return {Promise<any>} Returns a promise
+   * @return {Promise<AndroidPermissionResponse>} Returns a promise
    */
   @Cordova()
-  hasPermission(permission: string): Promise<any> {
+  hasPermission(permission: string): Promise<AndroidPermissionResponse> {
     return;
   }
 }
+
+export interface AndroidPermissionResponse {
+  hasPermission: boolean;
+}

src/@ionic-native/plugins/anyline/index.ts

@@ -0,0 +1,51 @@
+import { Injectable } from '@angular/core';
+import { Cordova, IonicNativePlugin, Plugin } from '@ionic-native/core';
+
+export interface AnylineOptions {
+  // Valid License Key
+  licenseKey: string;
+
+  // Scanning options
+  config: any;
+}
+
+/**
+ * @name Anyline
+ * @description
+ * Anyline provides an easy-to-use SDK for applications to enable Optical Character Recognition (OCR) on mobile devices.
+ *
+ * @usage
+ * ```typescript
+ * import { Anyline } from '@ionic-native/anyline/ngx';
+ *
+ *
+ * constructor(private anyline: Anyline) { }
+ *
+ * ...
+ *
+ *
+ * this.anyline.scan(options)
+ *   .then((res: any) => console.log(res))
+ *   .catch((error: any) => console.error(error));
+ *
+ * ```
+ */
+@Plugin({
+  pluginName: 'Anyline',
+  plugin: 'io-anyline-cordova',
+  pluginRef: 'Anyline',
+  repo: 'https://github.com/Anyline/anyline-ocr-cordova-module',
+  platforms: ['Android', 'iOS']
+})
+@Injectable()
+export class Anyline extends IonicNativePlugin {
+  /**
+   * Scan
+   * @param options {AnylineOptions} Scanning options
+   * @return {Promise<any>} Returns a promise that resolves when Code is captured
+   */
+  @Cordova()
+  scan(options: AnylineOptions): Promise<any> {
+    return;
+  }
+}