From ea77a41feac7d9746afa5a279e1781963e8d75e0 Mon Sep 17 00:00:00 2001 From: Akshay Date: Wed, 28 Aug 2024 15:22:37 +0530 Subject: [PATCH] Added dist library folders --- libraries/we-cap-inbox/index.js | 74 +++++++ libraries/we-cap-inbox/ngx/bundle.js | 119 +++++++++++ libraries/we-cap-inbox/ngx/index.js | 90 ++++++++ libraries/webengage/index.js | 149 ++++++++++++++ libraries/webengage/ngx/bundle.js | 294 +++++++++++++++++++++++++++ libraries/webengage/ngx/index.js | 265 ++++++++++++++++++++++++ 6 files changed, 991 insertions(+) create mode 100644 libraries/we-cap-inbox/index.js create mode 100644 libraries/we-cap-inbox/ngx/bundle.js create mode 100644 libraries/we-cap-inbox/ngx/index.js create mode 100644 libraries/webengage/index.js create mode 100644 libraries/webengage/ngx/bundle.js create mode 100644 libraries/webengage/ngx/index.js diff --git a/libraries/we-cap-inbox/index.js b/libraries/we-cap-inbox/index.js new file mode 100644 index 000000000..749a5dbd4 --- /dev/null +++ b/libraries/we-cap-inbox/index.js @@ -0,0 +1,74 @@ +var __extends = + (this && this.__extends) || + (function () { + var extendStatics = function (d, b) { + extendStatics = + Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && + function (d, b) { + d.__proto__ = b; + }) || + function (d, b) { + for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; + }; + return extendStatics(d, b); + }; + return function (d, b) { + if (typeof b !== 'function' && b !== null) + throw new TypeError('Class extends value ' + String(b) + ' is not a constructor or null'); + extendStatics(d, b); + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : ((__.prototype = b.prototype), new __()); + }; + })(); +import { AwesomeCordovaNativePlugin, cordova } from '@awesome-cordova-plugins/core'; +var WECapInboxOriginal = /** @class */ (function (_super) { + __extends(WECapInboxOriginal, _super); + function WECapInboxOriginal() { + return (_super !== null && _super.apply(this, arguments)) || this; + } + WECapInboxOriginal.prototype.resetNotificationCount = function () { + return cordova(this, 'resetNotificationCount', {}, arguments); + }; + WECapInboxOriginal.prototype.getNotificationCount = function (successCallback, errorCallback) { + return cordova(this, 'getNotificationCount', {}, arguments); + }; + WECapInboxOriginal.prototype.getNotificationList = function (offset, successCallback, errorCallback) { + return cordova(this, 'getNotificationList', {}, arguments); + }; + WECapInboxOriginal.prototype.markRead = function (notificationObject) { + return cordova(this, 'markRead', {}, arguments); + }; + WECapInboxOriginal.prototype.markUnread = function (notificationObject) { + return cordova(this, 'markUnread', {}, arguments); + }; + WECapInboxOriginal.prototype.trackClick = function (notificationObject) { + return cordova(this, 'trackClick', {}, arguments); + }; + WECapInboxOriginal.prototype.trackView = function (notificationObject) { + return cordova(this, 'trackView', {}, arguments); + }; + WECapInboxOriginal.prototype.markDelete = function (notificationObject) { + return cordova(this, 'markDelete', {}, arguments); + }; + WECapInboxOriginal.prototype.readAll = function (notificationList) { + return cordova(this, 'readAll', {}, arguments); + }; + WECapInboxOriginal.prototype.unReadAll = function (notificationList) { + return cordova(this, 'unReadAll', {}, arguments); + }; + WECapInboxOriginal.prototype.deleteAll = function (notificationList) { + return cordova(this, 'deleteAll', {}, arguments); + }; + WECapInboxOriginal.pluginName = 'WECapInbox'; + WECapInboxOriginal.plugin = 'we-notificationinbox-cordova'; + WECapInboxOriginal.pluginRef = 'WENotificationInboxPlugin'; + WECapInboxOriginal.repo = 'https://github.com/WebEngage/we-ionic-notification-inbox'; + WECapInboxOriginal.platforms = ['Android', 'iOS']; + return WECapInboxOriginal; +})(AwesomeCordovaNativePlugin); +var WECapInbox = new WECapInboxOriginal(); +export { WECapInbox }; +//# sourceMappingURL=data:application/json;base64,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 diff --git a/libraries/we-cap-inbox/ngx/bundle.js b/libraries/we-cap-inbox/ngx/bundle.js new file mode 100644 index 000000000..4c5ab389c --- /dev/null +++ b/libraries/we-cap-inbox/ngx/bundle.js @@ -0,0 +1,119 @@ +'use strict'; + +var tslib = require('tslib'); +var i0 = require('@angular/core'); +var core = require('@awesome-cordova-plugins/core'); + +function _interopNamespaceDefault(e) { + var n = Object.create(null); + if (e) { + Object.keys(e).forEach(function (k) { + if (k !== 'default') { + var d = Object.getOwnPropertyDescriptor(e, k); + Object.defineProperty( + n, + k, + d.get + ? d + : { + enumerable: true, + get: function () { + return e[k]; + }, + } + ); + } + }); + } + n.default = e; + return Object.freeze(n); +} + +var i0__namespace = /*#__PURE__*/ _interopNamespaceDefault(i0); + +var WECapInbox = /** @class */ (function (_super) { + tslib.__extends(WECapInbox, _super); + function WECapInbox() { + return (_super !== null && _super.apply(this, arguments)) || this; + } + WECapInbox.prototype.resetNotificationCount = function () { + return core.cordova(this, 'resetNotificationCount', {}, arguments); + }; + WECapInbox.prototype.getNotificationCount = function (successCallback, errorCallback) { + return core.cordova(this, 'getNotificationCount', {}, arguments); + }; + WECapInbox.prototype.getNotificationList = function (offset, successCallback, errorCallback) { + return core.cordova(this, 'getNotificationList', {}, arguments); + }; + WECapInbox.prototype.markRead = function (notificationObject) { + return core.cordova(this, 'markRead', {}, arguments); + }; + WECapInbox.prototype.markUnread = function (notificationObject) { + return core.cordova(this, 'markUnread', {}, arguments); + }; + WECapInbox.prototype.trackClick = function (notificationObject) { + return core.cordova(this, 'trackClick', {}, arguments); + }; + WECapInbox.prototype.trackView = function (notificationObject) { + return core.cordova(this, 'trackView', {}, arguments); + }; + WECapInbox.prototype.markDelete = function (notificationObject) { + return core.cordova(this, 'markDelete', {}, arguments); + }; + WECapInbox.prototype.readAll = function (notificationList) { + return core.cordova(this, 'readAll', {}, arguments); + }; + WECapInbox.prototype.unReadAll = function (notificationList) { + return core.cordova(this, 'unReadAll', {}, arguments); + }; + WECapInbox.prototype.deleteAll = function (notificationList) { + return core.cordova(this, 'deleteAll', {}, arguments); + }; + WECapInbox.ɵfac = i0__namespace.ɵɵngDeclareFactory({ + minVersion: '12.0.0', + version: '12.2.17', + ngImport: i0__namespace, + type: WECapInbox, + deps: null, + target: i0__namespace.ɵɵFactoryTarget.Injectable, + }); + WECapInbox.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ + minVersion: '12.0.0', + version: '12.2.17', + ngImport: i0__namespace, + type: WECapInbox, + }); + WECapInbox.pluginName = 'WECapInbox'; + WECapInbox.plugin = 'we-notificationinbox-cordova'; + WECapInbox.pluginRef = 'WENotificationInboxPlugin'; + WECapInbox.repo = 'https://github.com/WebEngage/we-ionic-notification-inbox'; + WECapInbox.platforms = ['Android', 'iOS']; + WECapInbox = tslib.__decorate([], WECapInbox); + return WECapInbox; +})(core.AwesomeCordovaNativePlugin); +i0__namespace.ɵɵngDeclareClassMetadata({ + minVersion: '12.0.0', + version: '12.2.17', + ngImport: i0__namespace, + type: WECapInbox, + decorators: [ + { + type: i0.Injectable, + }, + ], + propDecorators: { + resetNotificationCount: [], + getNotificationCount: [], + getNotificationList: [], + markRead: [], + markUnread: [], + trackClick: [], + trackView: [], + markDelete: [], + readAll: [], + unReadAll: [], + deleteAll: [], + }, +}); + +exports.WECapInbox = WECapInbox; diff --git a/libraries/we-cap-inbox/ngx/index.js b/libraries/we-cap-inbox/ngx/index.js new file mode 100644 index 000000000..7ab7c981e --- /dev/null +++ b/libraries/we-cap-inbox/ngx/index.js @@ -0,0 +1,90 @@ +import { __decorate, __extends } from 'tslib'; +import { Injectable } from '@angular/core'; +import { AwesomeCordovaNativePlugin, cordova } from '@awesome-cordova-plugins/core'; +import * as i0 from '@angular/core'; +var WECapInbox = /** @class */ (function (_super) { + __extends(WECapInbox, _super); + function WECapInbox() { + return (_super !== null && _super.apply(this, arguments)) || this; + } + WECapInbox.prototype.resetNotificationCount = function () { + return cordova(this, 'resetNotificationCount', {}, arguments); + }; + WECapInbox.prototype.getNotificationCount = function (successCallback, errorCallback) { + return cordova(this, 'getNotificationCount', {}, arguments); + }; + WECapInbox.prototype.getNotificationList = function (offset, successCallback, errorCallback) { + return cordova(this, 'getNotificationList', {}, arguments); + }; + WECapInbox.prototype.markRead = function (notificationObject) { + return cordova(this, 'markRead', {}, arguments); + }; + WECapInbox.prototype.markUnread = function (notificationObject) { + return cordova(this, 'markUnread', {}, arguments); + }; + WECapInbox.prototype.trackClick = function (notificationObject) { + return cordova(this, 'trackClick', {}, arguments); + }; + WECapInbox.prototype.trackView = function (notificationObject) { + return cordova(this, 'trackView', {}, arguments); + }; + WECapInbox.prototype.markDelete = function (notificationObject) { + return cordova(this, 'markDelete', {}, arguments); + }; + WECapInbox.prototype.readAll = function (notificationList) { + return cordova(this, 'readAll', {}, arguments); + }; + WECapInbox.prototype.unReadAll = function (notificationList) { + return cordova(this, 'unReadAll', {}, arguments); + }; + WECapInbox.prototype.deleteAll = function (notificationList) { + return cordova(this, 'deleteAll', {}, arguments); + }; + WECapInbox.ɵfac = i0.ɵɵngDeclareFactory({ + minVersion: '12.0.0', + version: '12.2.17', + ngImport: i0, + type: WECapInbox, + deps: null, + target: i0.ɵɵFactoryTarget.Injectable, + }); + WECapInbox.ɵprov = i0.ɵɵngDeclareInjectable({ + minVersion: '12.0.0', + version: '12.2.17', + ngImport: i0, + type: WECapInbox, + }); + WECapInbox.pluginName = 'WECapInbox'; + WECapInbox.plugin = 'we-notificationinbox-cordova'; + WECapInbox.pluginRef = 'WENotificationInboxPlugin'; + WECapInbox.repo = 'https://github.com/WebEngage/we-ionic-notification-inbox'; + WECapInbox.platforms = ['Android', 'iOS']; + WECapInbox = __decorate([], WECapInbox); + return WECapInbox; +})(AwesomeCordovaNativePlugin); +export { WECapInbox }; +i0.ɵɵngDeclareClassMetadata({ + minVersion: '12.0.0', + version: '12.2.17', + ngImport: i0, + type: WECapInbox, + decorators: [ + { + type: Injectable, + }, + ], + propDecorators: { + resetNotificationCount: [], + getNotificationCount: [], + getNotificationList: [], + markRead: [], + markUnread: [], + trackClick: [], + trackView: [], + markDelete: [], + readAll: [], + unReadAll: [], + deleteAll: [], + }, +}); +//# sourceMappingURL=data:application/json;base64,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 diff --git a/libraries/webengage/index.js b/libraries/webengage/index.js new file mode 100644 index 000000000..ed65f1ff2 --- /dev/null +++ b/libraries/webengage/index.js @@ -0,0 +1,149 @@ +var __extends = + (this && this.__extends) || + (function () { + var extendStatics = function (d, b) { + extendStatics = + Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && + function (d, b) { + d.__proto__ = b; + }) || + function (d, b) { + for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; + }; + return extendStatics(d, b); + }; + return function (d, b) { + if (typeof b !== 'function' && b !== null) + throw new TypeError('Class extends value ' + String(b) + ' is not a constructor or null'); + extendStatics(d, b); + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : ((__.prototype = b.prototype), new __()); + }; + })(); +import { AwesomeCordovaNativePlugin, cordova } from '@awesome-cordova-plugins/core'; +var WebengageOriginal = /** @class */ (function (_super) { + __extends(WebengageOriginal, _super); + function WebengageOriginal() { + return (_super !== null && _super.apply(this, arguments)) || this; + } + WebengageOriginal.prototype.engage = function (config) { + return cordova(this, 'engage', {}, arguments); + }; + WebengageOriginal.prototype.startGAIDTracking = function () { + return cordova(this, 'startGAIDTracking', {}, arguments); + }; + WebengageOriginal.prototype.options = function (key, value) { + return cordova(this, 'options', {}, arguments); + }; + WebengageOriginal.prototype.track = function (eventName, attributes) { + return cordova(this, 'track', {}, arguments); + }; + WebengageOriginal.prototype.screen = function (screenName, screenData) { + return cordova(this, 'screen', {}, arguments); + }; + WebengageOriginal.pluginName = 'Webengage'; + WebengageOriginal.plugin = 'cordova-plugin-webengage'; + WebengageOriginal.pluginRef = 'webengage'; + WebengageOriginal.repo = 'https://github.com/WebEngage/cordova-plugin'; + WebengageOriginal.platforms = ['Android', 'iOS']; + return WebengageOriginal; +})(AwesomeCordovaNativePlugin); +var Webengage = new WebengageOriginal(); +export { Webengage }; +var WebengageUserOriginal = /** @class */ (function (_super) { + __extends(WebengageUserOriginal, _super); + function WebengageUserOriginal() { + return (_super !== null && _super.apply(this, arguments)) || this; + } + WebengageUserOriginal.prototype.login = function (userId, jwtToken) { + return cordova(this, 'login', {}, arguments); + }; + WebengageUserOriginal.prototype.setSecureToken = function (userId, jwtToken) { + return cordova(this, 'setSecureToken', {}, arguments); + }; + WebengageUserOriginal.prototype.logout = function () { + return cordova(this, 'logout', {}, arguments); + }; + WebengageUserOriginal.prototype.setAttribute = function (key, value) { + return cordova(this, 'setAttribute', {}, arguments); + }; + WebengageUserOriginal.prototype.setDevicePushOptIn = function (optIn) { + return cordova(this, 'setDevicePushOptIn', {}, arguments); + }; + WebengageUserOriginal.prototype.setUserOptIn = function (channel, optIn) { + return cordova(this, 'setUserOptIn', {}, arguments); + }; + WebengageUserOriginal.prototype.setLocation = function (latitude, longitude) { + return cordova(this, 'setLocation', {}, arguments); + }; + WebengageUserOriginal.pluginName = 'Webengage'; + WebengageUserOriginal.plugin = 'cordova-plugin-webengage'; + WebengageUserOriginal.pluginRef = 'webengage.user'; + return WebengageUserOriginal; +})(AwesomeCordovaNativePlugin); +var WebengageUser = new WebengageUserOriginal(); +export { WebengageUser }; +var WebengageJwtManagerOriginal = /** @class */ (function (_super) { + __extends(WebengageJwtManagerOriginal, _super); + function WebengageJwtManagerOriginal() { + return (_super !== null && _super.apply(this, arguments)) || this; + } + WebengageJwtManagerOriginal.prototype.tokenInvalidatedCallback = function (callback) { + return cordova(this, 'tokenInvalidatedCallback', {}, arguments); + }; + WebengageJwtManagerOriginal.pluginName = 'Webengage'; + WebengageJwtManagerOriginal.plugin = 'cordova-plugin-webengage'; + WebengageJwtManagerOriginal.pluginRef = 'webengage.jwtManager'; + return WebengageJwtManagerOriginal; +})(AwesomeCordovaNativePlugin); +var WebengageJwtManager = new WebengageJwtManagerOriginal(); +export { WebengageJwtManager }; +var WebengagePushOriginal = /** @class */ (function (_super) { + __extends(WebengagePushOriginal, _super); + function WebengagePushOriginal() { + return (_super !== null && _super.apply(this, arguments)) || this; + } + WebengagePushOriginal.prototype.onClick = function (callback) { + return cordova(this, 'onClick', {}, arguments); + }; + WebengagePushOriginal.prototype.options = function (key, value) { + return cordova(this, 'options', {}, arguments); + }; + WebengagePushOriginal.pluginName = 'Webengage'; + WebengagePushOriginal.plugin = 'cordova-plugin-webengage'; + WebengagePushOriginal.pluginRef = 'webengage.push'; + return WebengagePushOriginal; +})(AwesomeCordovaNativePlugin); +var WebengagePush = new WebengagePushOriginal(); +export { WebengagePush }; +var WebengageNotificationOriginal = /** @class */ (function (_super) { + __extends(WebengageNotificationOriginal, _super); + function WebengageNotificationOriginal() { + return (_super !== null && _super.apply(this, arguments)) || this; + } + WebengageNotificationOriginal.prototype.onShown = function (callback) { + return cordova(this, 'onShown', {}, arguments); + }; + WebengageNotificationOriginal.prototype.onPrepared = function (callback) { + return cordova(this, 'onPrepared', {}, arguments); + }; + WebengageNotificationOriginal.prototype.onClick = function (callback) { + return cordova(this, 'onClick', {}, arguments); + }; + WebengageNotificationOriginal.prototype.onDismiss = function (callback) { + return cordova(this, 'onDismiss', {}, arguments); + }; + WebengageNotificationOriginal.prototype.options = function (key, value) { + return cordova(this, 'options', {}, arguments); + }; + WebengageNotificationOriginal.pluginName = 'Webengage'; + WebengageNotificationOriginal.plugin = 'cordova-plugin-webengage'; + WebengageNotificationOriginal.pluginRef = 'webengage.notification'; + return WebengageNotificationOriginal; +})(AwesomeCordovaNativePlugin); +var WebengageNotification = new WebengageNotificationOriginal(); +export { WebengageNotification }; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/@awesome-cordova-plugins/plugins/webengage/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AACA,OAAO,uCAA+C,MAAM,+BAA+B,CAAC;;IA0B7D,6BAA0B;;;;IAOvD,0BAAM,aAAC,MAAY;IASnB,qCAAiB;IAWjB,2BAAO,aAAC,GAAW,EAAE,KAAU;IAW/B,yBAAK,aAAC,SAAiB,EAAE,UAAgB;IAYzC,0BAAM,aAAC,UAAkB,EAAE,UAAgB;;;;;;oBA7E7C;EA2B+B,0BAA0B;SAA5C,SAAS;;IAgEa,iCAA0B;;;;IAO3D,6BAAK,aAAC,MAAc,EAAE,QAAiB;IAUvC,sCAAc,aAAC,MAAc,EAAE,QAAgB;IAS/C,8BAAM;IAWN,oCAAY,aAAC,GAAW,EAAE,KAAU;IAUpC,0CAAkB,aAAC,KAAc;IAWjC,oCAAY,aAAC,OAAe,EAAE,KAAU;IAWxC,mCAAW,aAAC,QAAgB,EAAE,SAAiB;;;;wBAhKjD;EA2FmC,0BAA0B;SAAhD,aAAa;;IAmFe,uCAA0B;;;;IAOjE,sDAAwB,aAAC,QAAa;;;;8BArLxC;EA8KyC,0BAA0B;SAAtD,mBAAmB;;IAqBG,iCAA0B;;;;IAO3D,+BAAO,aAAC,QAAa;IAWrB,+BAAO,aAAC,GAAW,EAAE,KAAU;;;;wBArNjC;EAmMmC,0BAA0B;SAAhD,aAAa;;IAgCiB,yCAA0B;;;;IAOnE,uCAAO,aAAC,QAAa;IAUrB,0CAAU,aAAC,QAAa;IAUxB,uCAAO,aAAC,QAAa;IAUrB,yCAAS,aAAC,QAAa;IAWvB,uCAAO,aAAC,GAAW,EAAE,KAAU;;;;gCAnRjC;EAmO2C,0BAA0B;SAAxD,qBAAqB","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Cordova, AwesomeCordovaNativePlugin, Plugin } from '@awesome-cordova-plugins/core';\n\n/**\n * @name Webengage\n * @description\n * Awesome Cordova Plugins wrapper that wraps Webengage Cordova plugin for Android and iOS\n * @usage\n * ```typescript\n * import { Webengage, WebengageUser, WebengagePush, WebengageNotification, WebengageJwtManager  } from '@awesome-cordova-plugins/webengage/ngx';\n *\n *\n * constructor(private webengage: Webengage, private webengageUser: WebengageUser, private webengagePush: WebengagePush, private webengageNotification: WebengageNotification ) { }\n *\n * ...\n *\n * this.webengage.engage();\n * ```\n */\n@Plugin({\n  pluginName: 'Webengage',\n  plugin: 'cordova-plugin-webengage',\n  pluginRef: 'webengage',\n  repo: 'https://github.com/WebEngage/cordova-plugin',\n  platforms: ['Android', 'iOS'],\n})\n@Injectable()\nexport class Webengage extends AwesomeCordovaNativePlugin {\n  /**\n   * Initializes WebEngage SDK\n   * @param {any} [config]\n   * @returns {Promise<any>}\n   */\n  @Cordova()\n  engage(config?: any): Promise<any> {\n    return;\n  }\n\n  /**\n   * Starts Tracking Google Advertising ID\n   * @returns {Promise<any>}\n   */\n  @Cordova()\n  startGAIDTracking(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Sets WebEngage SDK configuration\n   * @param {string} key\n   * @param {any} value\n   * @returns {Promise<any>}\n   */\n  @Cordova()\n  options(key: string, value: any): Promise<any> {\n    return;\n  }\n\n  /**\n   * Tracks event\n   * @param {string} eventName\n   * @param {any} [attributes]\n   * @returns {Promise<any>}\n   */\n  @Cordova()\n  track(eventName: string, attributes?: any): Promise<any> {\n    return;\n  }\n\n  /**\n   * Tracks screen\n   * @param {string} eventName\n   * @param screenName\n   * @param {any} [screenData]\n   * @returns {Promise<any>}\n   */\n  @Cordova()\n  screen(screenName: string, screenData?: any): Promise<any> {\n    return;\n  }\n}\n\n/**\n * @hidden\n */\n@Plugin({\n  pluginName: 'Webengage',\n  plugin: 'cordova-plugin-webengage',\n  pluginRef: 'webengage.user',\n})\n@Injectable()\nexport class WebengageUser extends AwesomeCordovaNativePlugin {\n  /**\n   * Logs user in\n   * @param {string} userId\n   * @returns {Promise<any>}\n   */\n  @Cordova()\n  login(userId: string, jwtToken?: string): Promise<any> {\n    return;\n  }\n\n  /**\n   * Logs user in\n   * @param {string} userId\n   * @returns {Promise<any>}\n   */\n  @Cordova()\n  setSecureToken(userId: string, jwtToken: string): Promise<any> {\n    return;\n  }\n\n  /**\n   * Logs user out\n   * @returns {Promise<any>}\n   */\n  @Cordova()\n  logout(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Sets user attribute\n   * @param {string} key\n   * @param {any} value\n   * @returns {Promise<any>}\n   */\n  @Cordova()\n  setAttribute(key: string, value: any): Promise<any> {\n    return;\n  }\n\n  /**\n   * Sets Device optIn\n   * @param {boolean} optIn\n   * @returns {Promise<any>}\n   */\n  @Cordova()\n  setDevicePushOptIn(optIn: boolean): Promise<any> {\n    return;\n  }\n\n  /**\n   * Sets user attribute\n   * @param {string} channel\n   * @param {any} optIn\n   * @returns {Promise<any>}\n   */\n  @Cordova()\n  setUserOptIn(channel: string, optIn: any): Promise<any> {\n    return;\n  }\n\n  /**\n   * Sets user location\n   * @param {number} latitude\n   * @param {number} longitude\n   * @returns {Promise<any>}\n   */\n  @Cordova()\n  setLocation(latitude: number, longitude: number): Promise<any> {\n    return;\n  }\n}\n\n/**\n * @hidden\n */\n@Plugin({\n  pluginName: 'Webengage',\n  plugin: 'cordova-plugin-webengage',\n  pluginRef: 'webengage.jwtManager',\n})\n@Injectable()\nexport class WebengageJwtManager extends AwesomeCordovaNativePlugin {\n  /**\n   * Callback function is invoked when a Jwt token is clicked\n   * @param {any} callback\n   * @returns {Promise<any>}\n   */\n  @Cordova()\n  tokenInvalidatedCallback(callback: any): Promise<any> {\n    return;\n  }\n}\n\n/**\n * @hidden\n */\n@Plugin({\n  pluginName: 'Webengage',\n  plugin: 'cordova-plugin-webengage',\n  pluginRef: 'webengage.push',\n})\n@Injectable()\nexport class WebengagePush extends AwesomeCordovaNativePlugin {\n  /**\n   * Callback function is invoked when a push notification is clicked\n   * @param {any} callback\n   * @returns {Promise<any>}\n   */\n  @Cordova()\n  onClick(callback: any): Promise<any> {\n    return;\n  }\n\n  /**\n   * Sets push notification configuration\n   * @param {string} key\n   * @param {any} value\n   * @returns {Promise<any>}\n   */\n  @Cordova()\n  options(key: string, value: any): Promise<any> {\n    return;\n  }\n}\n\n/**\n * @hidden\n */\n@Plugin({\n  pluginName: 'Webengage',\n  plugin: 'cordova-plugin-webengage',\n  pluginRef: 'webengage.notification',\n})\n@Injectable()\nexport class WebengageNotification extends AwesomeCordovaNativePlugin {\n  /**\n   * Callback function is invoked when a in-app notification is shown\n   * @param {any} callback\n   * @returns {Promise<any>}\n   */\n  @Cordova()\n  onShown(callback: any): Promise<any> {\n    return;\n  }\n\n  /**\n   * Callback function is invoked before a in-app notification is shown\n   * @param {any} callback\n   * @returns {Promise<any>}\n   */\n  @Cordova()\n  onPrepared(callback: any): Promise<any> {\n    return;\n  }\n\n  /**\n   * Callback function is invoked when a in-app notification is clicked\n   * @param {any} callback\n   * @returns {Promise<any>}\n   */\n  @Cordova()\n  onClick(callback: any): Promise<any> {\n    return;\n  }\n\n  /**\n   * Callback function is invoked when a in-app notification is dismissed\n   * @param {any} callback\n   * @returns {Promise<any>}\n   */\n  @Cordova()\n  onDismiss(callback: any): Promise<any> {\n    return;\n  }\n\n  /**\n   * Sets in-app notification configuration\n   * @param {string} key\n   * @param {any} value\n   * @returns {Promise<any>}\n   */\n  @Cordova()\n  options(key: string, value: any): Promise<any> {\n    return;\n  }\n}\n"]} diff --git a/libraries/webengage/ngx/bundle.js b/libraries/webengage/ngx/bundle.js new file mode 100644 index 000000000..b30398af6 --- /dev/null +++ b/libraries/webengage/ngx/bundle.js @@ -0,0 +1,294 @@ +'use strict'; + +var tslib = require('tslib'); +var i0 = require('@angular/core'); +var core = require('@awesome-cordova-plugins/core'); + +function _interopNamespaceDefault(e) { + var n = Object.create(null); + if (e) { + Object.keys(e).forEach(function (k) { + if (k !== 'default') { + var d = Object.getOwnPropertyDescriptor(e, k); + Object.defineProperty( + n, + k, + d.get + ? d + : { + enumerable: true, + get: function () { + return e[k]; + }, + } + ); + } + }); + } + n.default = e; + return Object.freeze(n); +} + +var i0__namespace = /*#__PURE__*/ _interopNamespaceDefault(i0); + +var Webengage = /** @class */ (function (_super) { + tslib.__extends(Webengage, _super); + function Webengage() { + return (_super !== null && _super.apply(this, arguments)) || this; + } + Webengage.prototype.engage = function (config) { + return core.cordova(this, 'engage', {}, arguments); + }; + Webengage.prototype.startGAIDTracking = function () { + return core.cordova(this, 'startGAIDTracking', {}, arguments); + }; + Webengage.prototype.options = function (key, value) { + return core.cordova(this, 'options', {}, arguments); + }; + Webengage.prototype.track = function (eventName, attributes) { + return core.cordova(this, 'track', {}, arguments); + }; + Webengage.prototype.screen = function (screenName, screenData) { + return core.cordova(this, 'screen', {}, arguments); + }; + Webengage.ɵfac = i0__namespace.ɵɵngDeclareFactory({ + minVersion: '12.0.0', + version: '12.2.17', + ngImport: i0__namespace, + type: Webengage, + deps: null, + target: i0__namespace.ɵɵFactoryTarget.Injectable, + }); + Webengage.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ + minVersion: '12.0.0', + version: '12.2.17', + ngImport: i0__namespace, + type: Webengage, + }); + Webengage.pluginName = 'Webengage'; + Webengage.plugin = 'cordova-plugin-webengage'; + Webengage.pluginRef = 'webengage'; + Webengage.repo = 'https://github.com/WebEngage/cordova-plugin'; + Webengage.platforms = ['Android', 'iOS']; + Webengage = tslib.__decorate([], Webengage); + return Webengage; +})(core.AwesomeCordovaNativePlugin); +i0__namespace.ɵɵngDeclareClassMetadata({ + minVersion: '12.0.0', + version: '12.2.17', + ngImport: i0__namespace, + type: Webengage, + decorators: [ + { + type: i0.Injectable, + }, + ], + propDecorators: { engage: [], startGAIDTracking: [], options: [], track: [], screen: [] }, +}); +var WebengageUser = /** @class */ (function (_super) { + tslib.__extends(WebengageUser, _super); + function WebengageUser() { + return (_super !== null && _super.apply(this, arguments)) || this; + } + WebengageUser.prototype.login = function (userId, jwtToken) { + return core.cordova(this, 'login', {}, arguments); + }; + WebengageUser.prototype.setSecureToken = function (userId, jwtToken) { + return core.cordova(this, 'setSecureToken', {}, arguments); + }; + WebengageUser.prototype.logout = function () { + return core.cordova(this, 'logout', {}, arguments); + }; + WebengageUser.prototype.setAttribute = function (key, value) { + return core.cordova(this, 'setAttribute', {}, arguments); + }; + WebengageUser.prototype.setDevicePushOptIn = function (optIn) { + return core.cordova(this, 'setDevicePushOptIn', {}, arguments); + }; + WebengageUser.prototype.setUserOptIn = function (channel, optIn) { + return core.cordova(this, 'setUserOptIn', {}, arguments); + }; + WebengageUser.prototype.setLocation = function (latitude, longitude) { + return core.cordova(this, 'setLocation', {}, arguments); + }; + WebengageUser.ɵfac = i0__namespace.ɵɵngDeclareFactory({ + minVersion: '12.0.0', + version: '12.2.17', + ngImport: i0__namespace, + type: WebengageUser, + deps: null, + target: i0__namespace.ɵɵFactoryTarget.Injectable, + }); + WebengageUser.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ + minVersion: '12.0.0', + version: '12.2.17', + ngImport: i0__namespace, + type: WebengageUser, + }); + WebengageUser.pluginName = 'Webengage'; + WebengageUser.plugin = 'cordova-plugin-webengage'; + WebengageUser.pluginRef = 'webengage.user'; + WebengageUser = tslib.__decorate([], WebengageUser); + return WebengageUser; +})(core.AwesomeCordovaNativePlugin); +i0__namespace.ɵɵngDeclareClassMetadata({ + minVersion: '12.0.0', + version: '12.2.17', + ngImport: i0__namespace, + type: WebengageUser, + decorators: [ + { + type: i0.Injectable, + }, + ], + propDecorators: { + login: [], + setSecureToken: [], + logout: [], + setAttribute: [], + setDevicePushOptIn: [], + setUserOptIn: [], + setLocation: [], + }, +}); +var WebengageJwtManager = /** @class */ (function (_super) { + tslib.__extends(WebengageJwtManager, _super); + function WebengageJwtManager() { + return (_super !== null && _super.apply(this, arguments)) || this; + } + WebengageJwtManager.prototype.tokenInvalidatedCallback = function (callback) { + return core.cordova(this, 'tokenInvalidatedCallback', {}, arguments); + }; + WebengageJwtManager.ɵfac = i0__namespace.ɵɵngDeclareFactory({ + minVersion: '12.0.0', + version: '12.2.17', + ngImport: i0__namespace, + type: WebengageJwtManager, + deps: null, + target: i0__namespace.ɵɵFactoryTarget.Injectable, + }); + WebengageJwtManager.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ + minVersion: '12.0.0', + version: '12.2.17', + ngImport: i0__namespace, + type: WebengageJwtManager, + }); + WebengageJwtManager.pluginName = 'Webengage'; + WebengageJwtManager.plugin = 'cordova-plugin-webengage'; + WebengageJwtManager.pluginRef = 'webengage.jwtManager'; + WebengageJwtManager = tslib.__decorate([], WebengageJwtManager); + return WebengageJwtManager; +})(core.AwesomeCordovaNativePlugin); +i0__namespace.ɵɵngDeclareClassMetadata({ + minVersion: '12.0.0', + version: '12.2.17', + ngImport: i0__namespace, + type: WebengageJwtManager, + decorators: [ + { + type: i0.Injectable, + }, + ], + propDecorators: { tokenInvalidatedCallback: [] }, +}); +var WebengagePush = /** @class */ (function (_super) { + tslib.__extends(WebengagePush, _super); + function WebengagePush() { + return (_super !== null && _super.apply(this, arguments)) || this; + } + WebengagePush.prototype.onClick = function (callback) { + return core.cordova(this, 'onClick', {}, arguments); + }; + WebengagePush.prototype.options = function (key, value) { + return core.cordova(this, 'options', {}, arguments); + }; + WebengagePush.ɵfac = i0__namespace.ɵɵngDeclareFactory({ + minVersion: '12.0.0', + version: '12.2.17', + ngImport: i0__namespace, + type: WebengagePush, + deps: null, + target: i0__namespace.ɵɵFactoryTarget.Injectable, + }); + WebengagePush.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ + minVersion: '12.0.0', + version: '12.2.17', + ngImport: i0__namespace, + type: WebengagePush, + }); + WebengagePush.pluginName = 'Webengage'; + WebengagePush.plugin = 'cordova-plugin-webengage'; + WebengagePush.pluginRef = 'webengage.push'; + WebengagePush = tslib.__decorate([], WebengagePush); + return WebengagePush; +})(core.AwesomeCordovaNativePlugin); +i0__namespace.ɵɵngDeclareClassMetadata({ + minVersion: '12.0.0', + version: '12.2.17', + ngImport: i0__namespace, + type: WebengagePush, + decorators: [ + { + type: i0.Injectable, + }, + ], + propDecorators: { onClick: [], options: [] }, +}); +var WebengageNotification = /** @class */ (function (_super) { + tslib.__extends(WebengageNotification, _super); + function WebengageNotification() { + return (_super !== null && _super.apply(this, arguments)) || this; + } + WebengageNotification.prototype.onShown = function (callback) { + return core.cordova(this, 'onShown', {}, arguments); + }; + WebengageNotification.prototype.onPrepared = function (callback) { + return core.cordova(this, 'onPrepared', {}, arguments); + }; + WebengageNotification.prototype.onClick = function (callback) { + return core.cordova(this, 'onClick', {}, arguments); + }; + WebengageNotification.prototype.onDismiss = function (callback) { + return core.cordova(this, 'onDismiss', {}, arguments); + }; + WebengageNotification.prototype.options = function (key, value) { + return core.cordova(this, 'options', {}, arguments); + }; + WebengageNotification.ɵfac = i0__namespace.ɵɵngDeclareFactory({ + minVersion: '12.0.0', + version: '12.2.17', + ngImport: i0__namespace, + type: WebengageNotification, + deps: null, + target: i0__namespace.ɵɵFactoryTarget.Injectable, + }); + WebengageNotification.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ + minVersion: '12.0.0', + version: '12.2.17', + ngImport: i0__namespace, + type: WebengageNotification, + }); + WebengageNotification.pluginName = 'Webengage'; + WebengageNotification.plugin = 'cordova-plugin-webengage'; + WebengageNotification.pluginRef = 'webengage.notification'; + WebengageNotification = tslib.__decorate([], WebengageNotification); + return WebengageNotification; +})(core.AwesomeCordovaNativePlugin); +i0__namespace.ɵɵngDeclareClassMetadata({ + minVersion: '12.0.0', + version: '12.2.17', + ngImport: i0__namespace, + type: WebengageNotification, + decorators: [ + { + type: i0.Injectable, + }, + ], + propDecorators: { onShown: [], onPrepared: [], onClick: [], onDismiss: [], options: [] }, +}); + +exports.Webengage = Webengage; +exports.WebengageJwtManager = WebengageJwtManager; +exports.WebengageNotification = WebengageNotification; +exports.WebengagePush = WebengagePush; +exports.WebengageUser = WebengageUser; diff --git a/libraries/webengage/ngx/index.js b/libraries/webengage/ngx/index.js new file mode 100644 index 000000000..4064afab2 --- /dev/null +++ b/libraries/webengage/ngx/index.js @@ -0,0 +1,265 @@ +import { __decorate, __extends } from 'tslib'; +import { Injectable } from '@angular/core'; +import { AwesomeCordovaNativePlugin, cordova } from '@awesome-cordova-plugins/core'; +import * as i0 from '@angular/core'; +var Webengage = /** @class */ (function (_super) { + __extends(Webengage, _super); + function Webengage() { + return (_super !== null && _super.apply(this, arguments)) || this; + } + Webengage.prototype.engage = function (config) { + return cordova(this, 'engage', {}, arguments); + }; + Webengage.prototype.startGAIDTracking = function () { + return cordova(this, 'startGAIDTracking', {}, arguments); + }; + Webengage.prototype.options = function (key, value) { + return cordova(this, 'options', {}, arguments); + }; + Webengage.prototype.track = function (eventName, attributes) { + return cordova(this, 'track', {}, arguments); + }; + Webengage.prototype.screen = function (screenName, screenData) { + return cordova(this, 'screen', {}, arguments); + }; + Webengage.ɵfac = i0.ɵɵngDeclareFactory({ + minVersion: '12.0.0', + version: '12.2.17', + ngImport: i0, + type: Webengage, + deps: null, + target: i0.ɵɵFactoryTarget.Injectable, + }); + Webengage.ɵprov = i0.ɵɵngDeclareInjectable({ + minVersion: '12.0.0', + version: '12.2.17', + ngImport: i0, + type: Webengage, + }); + Webengage.pluginName = 'Webengage'; + Webengage.plugin = 'cordova-plugin-webengage'; + Webengage.pluginRef = 'webengage'; + Webengage.repo = 'https://github.com/WebEngage/cordova-plugin'; + Webengage.platforms = ['Android', 'iOS']; + Webengage = __decorate([], Webengage); + return Webengage; +})(AwesomeCordovaNativePlugin); +export { Webengage }; +i0.ɵɵngDeclareClassMetadata({ + minVersion: '12.0.0', + version: '12.2.17', + ngImport: i0, + type: Webengage, + decorators: [ + { + type: Injectable, + }, + ], + propDecorators: { engage: [], startGAIDTracking: [], options: [], track: [], screen: [] }, +}); +var WebengageUser = /** @class */ (function (_super) { + __extends(WebengageUser, _super); + function WebengageUser() { + return (_super !== null && _super.apply(this, arguments)) || this; + } + WebengageUser.prototype.login = function (userId, jwtToken) { + return cordova(this, 'login', {}, arguments); + }; + WebengageUser.prototype.setSecureToken = function (userId, jwtToken) { + return cordova(this, 'setSecureToken', {}, arguments); + }; + WebengageUser.prototype.logout = function () { + return cordova(this, 'logout', {}, arguments); + }; + WebengageUser.prototype.setAttribute = function (key, value) { + return cordova(this, 'setAttribute', {}, arguments); + }; + WebengageUser.prototype.setDevicePushOptIn = function (optIn) { + return cordova(this, 'setDevicePushOptIn', {}, arguments); + }; + WebengageUser.prototype.setUserOptIn = function (channel, optIn) { + return cordova(this, 'setUserOptIn', {}, arguments); + }; + WebengageUser.prototype.setLocation = function (latitude, longitude) { + return cordova(this, 'setLocation', {}, arguments); + }; + WebengageUser.ɵfac = i0.ɵɵngDeclareFactory({ + minVersion: '12.0.0', + version: '12.2.17', + ngImport: i0, + type: WebengageUser, + deps: null, + target: i0.ɵɵFactoryTarget.Injectable, + }); + WebengageUser.ɵprov = i0.ɵɵngDeclareInjectable({ + minVersion: '12.0.0', + version: '12.2.17', + ngImport: i0, + type: WebengageUser, + }); + WebengageUser.pluginName = 'Webengage'; + WebengageUser.plugin = 'cordova-plugin-webengage'; + WebengageUser.pluginRef = 'webengage.user'; + WebengageUser = __decorate([], WebengageUser); + return WebengageUser; +})(AwesomeCordovaNativePlugin); +export { WebengageUser }; +i0.ɵɵngDeclareClassMetadata({ + minVersion: '12.0.0', + version: '12.2.17', + ngImport: i0, + type: WebengageUser, + decorators: [ + { + type: Injectable, + }, + ], + propDecorators: { + login: [], + setSecureToken: [], + logout: [], + setAttribute: [], + setDevicePushOptIn: [], + setUserOptIn: [], + setLocation: [], + }, +}); +var WebengageJwtManager = /** @class */ (function (_super) { + __extends(WebengageJwtManager, _super); + function WebengageJwtManager() { + return (_super !== null && _super.apply(this, arguments)) || this; + } + WebengageJwtManager.prototype.tokenInvalidatedCallback = function (callback) { + return cordova(this, 'tokenInvalidatedCallback', {}, arguments); + }; + WebengageJwtManager.ɵfac = i0.ɵɵngDeclareFactory({ + minVersion: '12.0.0', + version: '12.2.17', + ngImport: i0, + type: WebengageJwtManager, + deps: null, + target: i0.ɵɵFactoryTarget.Injectable, + }); + WebengageJwtManager.ɵprov = i0.ɵɵngDeclareInjectable({ + minVersion: '12.0.0', + version: '12.2.17', + ngImport: i0, + type: WebengageJwtManager, + }); + WebengageJwtManager.pluginName = 'Webengage'; + WebengageJwtManager.plugin = 'cordova-plugin-webengage'; + WebengageJwtManager.pluginRef = 'webengage.jwtManager'; + WebengageJwtManager = __decorate([], WebengageJwtManager); + return WebengageJwtManager; +})(AwesomeCordovaNativePlugin); +export { WebengageJwtManager }; +i0.ɵɵngDeclareClassMetadata({ + minVersion: '12.0.0', + version: '12.2.17', + ngImport: i0, + type: WebengageJwtManager, + decorators: [ + { + type: Injectable, + }, + ], + propDecorators: { tokenInvalidatedCallback: [] }, +}); +var WebengagePush = /** @class */ (function (_super) { + __extends(WebengagePush, _super); + function WebengagePush() { + return (_super !== null && _super.apply(this, arguments)) || this; + } + WebengagePush.prototype.onClick = function (callback) { + return cordova(this, 'onClick', {}, arguments); + }; + WebengagePush.prototype.options = function (key, value) { + return cordova(this, 'options', {}, arguments); + }; + WebengagePush.ɵfac = i0.ɵɵngDeclareFactory({ + minVersion: '12.0.0', + version: '12.2.17', + ngImport: i0, + type: WebengagePush, + deps: null, + target: i0.ɵɵFactoryTarget.Injectable, + }); + WebengagePush.ɵprov = i0.ɵɵngDeclareInjectable({ + minVersion: '12.0.0', + version: '12.2.17', + ngImport: i0, + type: WebengagePush, + }); + WebengagePush.pluginName = 'Webengage'; + WebengagePush.plugin = 'cordova-plugin-webengage'; + WebengagePush.pluginRef = 'webengage.push'; + WebengagePush = __decorate([], WebengagePush); + return WebengagePush; +})(AwesomeCordovaNativePlugin); +export { WebengagePush }; +i0.ɵɵngDeclareClassMetadata({ + minVersion: '12.0.0', + version: '12.2.17', + ngImport: i0, + type: WebengagePush, + decorators: [ + { + type: Injectable, + }, + ], + propDecorators: { onClick: [], options: [] }, +}); +var WebengageNotification = /** @class */ (function (_super) { + __extends(WebengageNotification, _super); + function WebengageNotification() { + return (_super !== null && _super.apply(this, arguments)) || this; + } + WebengageNotification.prototype.onShown = function (callback) { + return cordova(this, 'onShown', {}, arguments); + }; + WebengageNotification.prototype.onPrepared = function (callback) { + return cordova(this, 'onPrepared', {}, arguments); + }; + WebengageNotification.prototype.onClick = function (callback) { + return cordova(this, 'onClick', {}, arguments); + }; + WebengageNotification.prototype.onDismiss = function (callback) { + return cordova(this, 'onDismiss', {}, arguments); + }; + WebengageNotification.prototype.options = function (key, value) { + return cordova(this, 'options', {}, arguments); + }; + WebengageNotification.ɵfac = i0.ɵɵngDeclareFactory({ + minVersion: '12.0.0', + version: '12.2.17', + ngImport: i0, + type: WebengageNotification, + deps: null, + target: i0.ɵɵFactoryTarget.Injectable, + }); + WebengageNotification.ɵprov = i0.ɵɵngDeclareInjectable({ + minVersion: '12.0.0', + version: '12.2.17', + ngImport: i0, + type: WebengageNotification, + }); + WebengageNotification.pluginName = 'Webengage'; + WebengageNotification.plugin = 'cordova-plugin-webengage'; + WebengageNotification.pluginRef = 'webengage.notification'; + WebengageNotification = __decorate([], WebengageNotification); + return WebengageNotification; +})(AwesomeCordovaNativePlugin); +export { WebengageNotification }; +i0.ɵɵngDeclareClassMetadata({ + minVersion: '12.0.0', + version: '12.2.17', + ngImport: i0, + type: WebengageNotification, + decorators: [ + { + type: Injectable, + }, + ], + propDecorators: { onShown: [], onPrepared: [], onClick: [], onDismiss: [], options: [] }, +}); +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/@awesome-cordova-plugins/plugins/webengage/ngx/index.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,uCAA+C,MAAM,+BAA+B,CAAC;;;IA0B7D,6BAA0B;;;;IAOvD,0BAAM,aAAC,MAAY;IASnB,qCAAiB;IAWjB,2BAAO,aAAC,GAAW,EAAE,KAAU;IAW/B,yBAAK,aAAC,SAAiB,EAAE,UAAgB;IAYzC,0BAAM,aAAC,UAAkB,EAAE,UAAgB;2GAlDhC,SAAS;+GAAT,SAAS;;;;;;IAAT,SAAS,kBAAT,SAAS;oBA3BtB;EA2B+B,0BAA0B;SAA5C,SAAS;4FAAT,SAAS;kBADrB,UAAU;8BAQT,MAAM,MASN,iBAAiB,MAWjB,OAAO,MAWP,KAAK,MAYL,MAAM;;IAc2B,iCAA0B;;;;IAO3D,6BAAK,aAAC,MAAc,EAAE,QAAiB;IAUvC,sCAAc,aAAC,MAAc,EAAE,QAAgB;IAS/C,8BAAM;IAWN,oCAAY,aAAC,GAAW,EAAE,KAAU;IAUpC,0CAAkB,aAAC,KAAc;IAWjC,oCAAY,aAAC,OAAe,EAAE,KAAU;IAWxC,mCAAW,aAAC,QAAgB,EAAE,SAAiB;+GArEpC,aAAa;mHAAb,aAAa;;;;IAAb,aAAa,kBAAb,aAAa;wBA3F1B;EA2FmC,0BAA0B;SAAhD,aAAa;4FAAb,aAAa;kBADzB,UAAU;8BAQT,KAAK,MAUL,cAAc,MASd,MAAM,MAWN,YAAY,MAUZ,kBAAkB,MAWlB,YAAY,MAWZ,WAAW;;IAc4B,uCAA0B;;;;IAOjE,sDAAwB,aAAC,QAAa;qHAP3B,mBAAmB;yHAAnB,mBAAmB;;;;IAAnB,mBAAmB,kBAAnB,mBAAmB;8BA9KhC;EA8KyC,0BAA0B;SAAtD,mBAAmB;4FAAnB,mBAAmB;kBAD/B,UAAU;8BAQT,wBAAwB;;IAcS,iCAA0B;;;;IAO3D,+BAAO,aAAC,QAAa;IAWrB,+BAAO,aAAC,GAAW,EAAE,KAAU;+GAlBpB,aAAa;mHAAb,aAAa;;;;IAAb,aAAa,kBAAb,aAAa;wBAnM1B;EAmMmC,0BAA0B;SAAhD,aAAa;4FAAb,aAAa;kBADzB,UAAU;8BAQT,OAAO,MAWP,OAAO;;IAckC,yCAA0B;;;;IAOnE,uCAAO,aAAC,QAAa;IAUrB,0CAAU,aAAC,QAAa;IAUxB,uCAAO,aAAC,QAAa;IAUrB,yCAAS,aAAC,QAAa;IAWvB,uCAAO,aAAC,GAAW,EAAE,KAAU;uHAhDpB,qBAAqB;2HAArB,qBAAqB;;;;IAArB,qBAAqB,kBAArB,qBAAqB;gCAnOlC;EAmO2C,0BAA0B;SAAxD,qBAAqB;4FAArB,qBAAqB;kBADjC,UAAU;8BAQT,OAAO,MAUP,UAAU,MAUV,OAAO,MAUP,SAAS,MAWT,OAAO","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Cordova, AwesomeCordovaNativePlugin, Plugin } from '@awesome-cordova-plugins/core';\n\n/**\n * @name Webengage\n * @description\n * Awesome Cordova Plugins wrapper that wraps Webengage Cordova plugin for Android and iOS\n * @usage\n * ```typescript\n * import { Webengage, WebengageUser, WebengagePush, WebengageNotification, WebengageJwtManager  } from '@awesome-cordova-plugins/webengage/ngx';\n *\n *\n * constructor(private webengage: Webengage, private webengageUser: WebengageUser, private webengagePush: WebengagePush, private webengageNotification: WebengageNotification ) { }\n *\n * ...\n *\n * this.webengage.engage();\n * ```\n */\n@Plugin({\n  pluginName: 'Webengage',\n  plugin: 'cordova-plugin-webengage',\n  pluginRef: 'webengage',\n  repo: 'https://github.com/WebEngage/cordova-plugin',\n  platforms: ['Android', 'iOS'],\n})\n@Injectable()\nexport class Webengage extends AwesomeCordovaNativePlugin {\n  /**\n   * Initializes WebEngage SDK\n   * @param {any} [config]\n   * @returns {Promise<any>}\n   */\n  @Cordova()\n  engage(config?: any): Promise<any> {\n    return;\n  }\n\n  /**\n   * Starts Tracking Google Advertising ID\n   * @returns {Promise<any>}\n   */\n  @Cordova()\n  startGAIDTracking(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Sets WebEngage SDK configuration\n   * @param {string} key\n   * @param {any} value\n   * @returns {Promise<any>}\n   */\n  @Cordova()\n  options(key: string, value: any): Promise<any> {\n    return;\n  }\n\n  /**\n   * Tracks event\n   * @param {string} eventName\n   * @param {any} [attributes]\n   * @returns {Promise<any>}\n   */\n  @Cordova()\n  track(eventName: string, attributes?: any): Promise<any> {\n    return;\n  }\n\n  /**\n   * Tracks screen\n   * @param {string} eventName\n   * @param screenName\n   * @param {any} [screenData]\n   * @returns {Promise<any>}\n   */\n  @Cordova()\n  screen(screenName: string, screenData?: any): Promise<any> {\n    return;\n  }\n}\n\n/**\n * @hidden\n */\n@Plugin({\n  pluginName: 'Webengage',\n  plugin: 'cordova-plugin-webengage',\n  pluginRef: 'webengage.user',\n})\n@Injectable()\nexport class WebengageUser extends AwesomeCordovaNativePlugin {\n  /**\n   * Logs user in\n   * @param {string} userId\n   * @returns {Promise<any>}\n   */\n  @Cordova()\n  login(userId: string, jwtToken?: string): Promise<any> {\n    return;\n  }\n\n  /**\n   * Logs user in\n   * @param {string} userId\n   * @returns {Promise<any>}\n   */\n  @Cordova()\n  setSecureToken(userId: string, jwtToken: string): Promise<any> {\n    return;\n  }\n\n  /**\n   * Logs user out\n   * @returns {Promise<any>}\n   */\n  @Cordova()\n  logout(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Sets user attribute\n   * @param {string} key\n   * @param {any} value\n   * @returns {Promise<any>}\n   */\n  @Cordova()\n  setAttribute(key: string, value: any): Promise<any> {\n    return;\n  }\n\n  /**\n   * Sets Device optIn\n   * @param {boolean} optIn\n   * @returns {Promise<any>}\n   */\n  @Cordova()\n  setDevicePushOptIn(optIn: boolean): Promise<any> {\n    return;\n  }\n\n  /**\n   * Sets user attribute\n   * @param {string} channel\n   * @param {any} optIn\n   * @returns {Promise<any>}\n   */\n  @Cordova()\n  setUserOptIn(channel: string, optIn: any): Promise<any> {\n    return;\n  }\n\n  /**\n   * Sets user location\n   * @param {number} latitude\n   * @param {number} longitude\n   * @returns {Promise<any>}\n   */\n  @Cordova()\n  setLocation(latitude: number, longitude: number): Promise<any> {\n    return;\n  }\n}\n\n/**\n * @hidden\n */\n@Plugin({\n  pluginName: 'Webengage',\n  plugin: 'cordova-plugin-webengage',\n  pluginRef: 'webengage.jwtManager',\n})\n@Injectable()\nexport class WebengageJwtManager extends AwesomeCordovaNativePlugin {\n  /**\n   * Callback function is invoked when a Jwt token is clicked\n   * @param {any} callback\n   * @returns {Promise<any>}\n   */\n  @Cordova()\n  tokenInvalidatedCallback(callback: any): Promise<any> {\n    return;\n  }\n}\n\n/**\n * @hidden\n */\n@Plugin({\n  pluginName: 'Webengage',\n  plugin: 'cordova-plugin-webengage',\n  pluginRef: 'webengage.push',\n})\n@Injectable()\nexport class WebengagePush extends AwesomeCordovaNativePlugin {\n  /**\n   * Callback function is invoked when a push notification is clicked\n   * @param {any} callback\n   * @returns {Promise<any>}\n   */\n  @Cordova()\n  onClick(callback: any): Promise<any> {\n    return;\n  }\n\n  /**\n   * Sets push notification configuration\n   * @param {string} key\n   * @param {any} value\n   * @returns {Promise<any>}\n   */\n  @Cordova()\n  options(key: string, value: any): Promise<any> {\n    return;\n  }\n}\n\n/**\n * @hidden\n */\n@Plugin({\n  pluginName: 'Webengage',\n  plugin: 'cordova-plugin-webengage',\n  pluginRef: 'webengage.notification',\n})\n@Injectable()\nexport class WebengageNotification extends AwesomeCordovaNativePlugin {\n  /**\n   * Callback function is invoked when a in-app notification is shown\n   * @param {any} callback\n   * @returns {Promise<any>}\n   */\n  @Cordova()\n  onShown(callback: any): Promise<any> {\n    return;\n  }\n\n  /**\n   * Callback function is invoked before a in-app notification is shown\n   * @param {any} callback\n   * @returns {Promise<any>}\n   */\n  @Cordova()\n  onPrepared(callback: any): Promise<any> {\n    return;\n  }\n\n  /**\n   * Callback function is invoked when a in-app notification is clicked\n   * @param {any} callback\n   * @returns {Promise<any>}\n   */\n  @Cordova()\n  onClick(callback: any): Promise<any> {\n    return;\n  }\n\n  /**\n   * Callback function is invoked when a in-app notification is dismissed\n   * @param {any} callback\n   * @returns {Promise<any>}\n   */\n  @Cordova()\n  onDismiss(callback: any): Promise<any> {\n    return;\n  }\n\n  /**\n   * Sets in-app notification configuration\n   * @param {string} key\n   * @param {any} value\n   * @returns {Promise<any>}\n   */\n  @Cordova()\n  options(key: string, value: any): Promise<any> {\n    return;\n  }\n}\n"]}