@ionic-native/core

  • Version 5.36.0
  • Published
  • 105 kB
  • 1 dependency
  • MIT license

Install

npm i @ionic-native/core
yarn add @ionic-native/core
pnpm add @ionic-native/core

Overview

Ionic Native - Native plugins for ionic apps

Index

Functions

function checkAvailability

checkAvailability: {
(pluginRef: string, methodName?: string, pluginName?: string):
| boolean
| { error: string };
(pluginObj: any, methodName?: string, pluginName?: string):
| boolean
| { error: string };
};
  • Checks if plugin/cordova is available {boolean | { error: string } }

function cordova

cordova: (
pluginObj: any,
methodName: string,
config: CordovaOptions,
args: IArguments | any[]
) => any;

    function Cordova

    Cordova: (config?: CordovaOptions) => MethodDecorator;

      function CordovaCheck

      CordovaCheck: (config?: CordovaOptions) => MethodDecorator;

        function cordovaFunctionOverride

        cordovaFunctionOverride: (
        pluginObj: any,
        methodName: string,
        args?: IArguments | any[]
        ) => any;

          function CordovaFunctionOverride

          CordovaFunctionOverride: () => MethodDecorator;

            function cordovaInstance

            cordovaInstance: (
            pluginObj: any,
            methodName: string,
            config: CordovaOptions,
            args: IArguments | any[]
            ) => any;

              function CordovaInstance

              CordovaInstance: (config?: CordovaOptions) => MethodDecorator;

                function CordovaProperty

                CordovaProperty: () => PropertyDecorator;

                  function cordovaPropertyGet

                  cordovaPropertyGet: (pluginObj: any, key: string) => any;

                    function cordovaPropertySet

                    cordovaPropertySet: (pluginObj: any, key: string, value: any) => void;

                      function getPromise

                      getPromise: <T>(
                      callback: (resolve: Function, reject?: Function) => any
                      ) => Promise<T>;

                        function instanceAvailability

                        instanceAvailability: (pluginObj: any, methodName?: string) => boolean;
                        • Checks if _objectInstance exists and has the method/property

                        function InstanceCheck

                        InstanceCheck: (config?: CordovaOptions) => MethodDecorator;

                          function InstanceProperty

                          InstanceProperty: () => PropertyDecorator;

                            function instancePropertyGet

                            instancePropertyGet: (pluginObj: any, key: string) => any;

                              function instancePropertySet

                              instancePropertySet: (pluginObj: any, key: string, value: any) => void;

                                function Plugin

                                Plugin: (config: PluginConfig) => ClassDecorator;

                                  function wrap

                                  wrap: (pluginObj: any, methodName: string, opts?: CordovaOptions) => WrapFn;

                                  Classes

                                  class IonicNativePlugin

                                  class IonicNativePlugin {}

                                    property install

                                    static install: string;

                                      property platforms

                                      static platforms: string[];

                                        property plugin

                                        static plugin: string;

                                          property pluginName

                                          static pluginName: string;

                                            property pluginRef

                                            static pluginRef: string;

                                              property repo

                                              static repo: string;

                                                method getPlugin

                                                static getPlugin: () => any;
                                                • Returns the original plugin object

                                                method getPluginInstallName

                                                static getPluginInstallName: () => string;
                                                • Returns the plugin's install name

                                                method getPluginName

                                                static getPluginName: () => string;
                                                • Returns the plugin's name

                                                method getPluginRef

                                                static getPluginRef: () => string;
                                                • Returns the plugin's reference

                                                method getSupportedPlatforms

                                                static getSupportedPlatforms: () => string[];
                                                • Returns the plugin's supported platforms

                                                method installed

                                                static installed: () => boolean;
                                                • Returns a boolean that indicates whether the plugin is installed {boolean}

                                                Interfaces

                                                interface CordovaOptions

                                                interface CordovaOptions {}

                                                  property callbackOrder

                                                  callbackOrder?: 'reverse';
                                                  • Callback order. Set to reverse if the success/error callbacks are the first 2 arguments that the wrapped method takes.

                                                  property callbackStyle

                                                  callbackStyle?: 'node' | 'object';
                                                  • Callback style

                                                  property clearFunction

                                                  clearFunction?: string;
                                                  • If observable is set to true, this can be set to a different function name that will cancel the observable.

                                                  property clearWithArgs

                                                  clearWithArgs?: boolean;
                                                  • 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.

                                                  property destruct

                                                  destruct?: boolean;

                                                    property element

                                                    element?: any;
                                                    • Element to attach the event listener to, this is optional, defaults to window

                                                    property errorIndex

                                                    errorIndex?: number;
                                                    • Set a custom index for the error callback function. This doesn't work if callbackOrder or callbackStyle are set.

                                                    property errorName

                                                    errorName?: string;
                                                    • Error function property name. This must be set if callbackStyle is set to object.

                                                    property event

                                                    event?: string;
                                                    • Event name, this must be set if eventObservable is set to true

                                                    property eventObservable

                                                    eventObservable?: boolean;
                                                    • Creates an observable that wraps a global event. Replaces document.addEventListener

                                                    property methodName

                                                    methodName?: string;
                                                    • If the method-name of the cordova plugin is different from the wrappers one, it can be defined here

                                                    property observable

                                                    observable?: boolean;
                                                    • Set to true to return an observable

                                                    property otherPromise

                                                    otherPromise?: boolean;
                                                    • Set to true if the wrapped method returns a promise

                                                    property platforms

                                                    platforms?: string[];
                                                    • Supported platforms

                                                    property successIndex

                                                    successIndex?: number;
                                                    • Set a custom index for the success callback function. This doesn't work if callbackOrder or callbackStyle are set.

                                                    property successName

                                                    successName?: string;
                                                    • Success function property name. This must be set if callbackStyle is set to object.

                                                    property sync

                                                    sync?: boolean;
                                                    • Set to true if the wrapped method is a sync function

                                                    interface PluginConfig

                                                    interface PluginConfig {}

                                                      property install

                                                      install?: string;
                                                      • Custom install command

                                                      property installVariables

                                                      installVariables?: string[];
                                                      • Available installation variables

                                                      property platforms

                                                      platforms?: string[];
                                                      • Supported platforms

                                                      property plugin

                                                      plugin: string;
                                                      • Plugin NPM package name

                                                      property pluginName

                                                      pluginName: string;
                                                      • Plugin name, this should match the class name

                                                      property pluginRef

                                                      pluginRef?: string;
                                                      • Plugin object reference

                                                      property repo

                                                      repo?: string;
                                                      • Github repository URL

                                                      index signature

                                                      [key: string]: any;

                                                        Package Files (9)

                                                        Dependencies (1)

                                                        Dev Dependencies (0)

                                                        No dev dependencies.

                                                        Peer Dependencies (1)

                                                        Badge

                                                        To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                        You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@ionic-native/core.

                                                        • Markdown
                                                          [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@ionic-native/core)
                                                        • HTML
                                                          <a href="https://www.jsdocs.io/package/@ionic-native/core"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>