react-native-mapp-plugin 1.4.2 → 2.0.0-beta.1

package/plugin/build/android.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withMappEngageAndroid = void 0;
+exports.updatePushHandling = updatePushHandling;
+const config_plugins_1 = require("@expo/config-plugins");
+const messageService = 'com.reactlibrary.MessageService';
+const sdkMessagingServices = [
+    'com.appoxee.shared.MappMessagingService',
+    'com.appoxee.push.fcm.MappMessagingService',
+];
+const managedMessagingServices = [messageService, ...sdkMessagingServices];
+const fineLocation = 'android.permission.ACCESS_FINE_LOCATION';
+const backgroundLocation = 'android.permission.ACCESS_BACKGROUND_LOCATION';
+function removeAll(items, predicate) {
+    return (items ?? []).filter(item => !predicate(item));
+}
+function updatePushHandling(androidManifest, pushHandling) {
+    const manifest = androidManifest.manifest;
+    const application = config_plugins_1.AndroidConfig.Manifest.getMainApplicationOrThrow(androidManifest);
+    application.service = removeAll(application.service, service => {
+        return managedMessagingServices.includes(service.$?.['android:name'])
+            && service.$?.['tools:node'] === 'remove';
+    });
+    manifest.$ = manifest.$ ?? {};
+    manifest.$['xmlns:tools'] = 'http://schemas.android.com/tools';
+    for (const serviceName of sdkMessagingServices) {
+        application.service.push({
+            $: {
+                'android:name': serviceName,
+                'tools:node': 'remove',
+            },
+        });
+    }
+    if (pushHandling === 'custom') {
+        application.service.push({
+            $: {
+                'android:name': messageService,
+                'tools:node': 'remove',
+            },
+        });
+    }
+    return androidManifest;
+}
+const withMappEngageAndroid = (config, props) => {
+    if (props.enableGeofencing) {
+        config = config_plugins_1.AndroidConfig.Permissions.withPermissions(config, [fineLocation, backgroundLocation]);
+    }
+    return (0, config_plugins_1.withAndroidManifest)(config, configWithManifest => {
+        configWithManifest.modResults = updatePushHandling(configWithManifest.modResults, props.pushHandling);
+        return configWithManifest;
+    });
+};
+exports.withMappEngageAndroid = withMappEngageAndroid;

package/plugin/build/index.d.ts

@@ -0,0 +1,8 @@
+import { ConfigPlugin } from '@expo/config-plugins';
+import type { MappExpoPluginProps } from './types';
+export declare const withMappEngage: ConfigPlugin<MappExpoPluginProps>;
+export type { MappExpoPluginProps } from './types';
+export { withMappEngageAndroid } from './android';
+export { withMappEngageIos, buildAppoxeeConfig, writeAppoxeeConfig } from './ios';
+export { validateAndNormalizeProps } from './validation';
+export default withMappEngage;

package/plugin/build/index.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAndNormalizeProps = exports.writeAppoxeeConfig = exports.buildAppoxeeConfig = exports.withMappEngageIos = exports.withMappEngageAndroid = exports.withMappEngage = void 0;
+const config_plugins_1 = require("@expo/config-plugins");
+const android_1 = require("./android");
+const ios_1 = require("./ios");
+const validation_1 = require("./validation");
+const pkg = require('../../package.json');
+const plugin = (config, props) => {
+    const normalized = (0, validation_1.validateAndNormalizeProps)(config, props);
+    config = (0, android_1.withMappEngageAndroid)(config, normalized.android);
+    config = (0, ios_1.withMappEngageIos)(config, normalized.ios);
+    return config;
+};
+exports.withMappEngage = (0, config_plugins_1.createRunOncePlugin)(plugin, 'react-native-mapp-plugin', pkg.version);
+var android_2 = require("./android");
+Object.defineProperty(exports, "withMappEngageAndroid", { enumerable: true, get: function () { return android_2.withMappEngageAndroid; } });
+var ios_2 = require("./ios");
+Object.defineProperty(exports, "withMappEngageIos", { enumerable: true, get: function () { return ios_2.withMappEngageIos; } });
+Object.defineProperty(exports, "buildAppoxeeConfig", { enumerable: true, get: function () { return ios_2.buildAppoxeeConfig; } });
+Object.defineProperty(exports, "writeAppoxeeConfig", { enumerable: true, get: function () { return ios_2.writeAppoxeeConfig; } });
+var validation_2 = require("./validation");
+Object.defineProperty(exports, "validateAndNormalizeProps", { enumerable: true, get: function () { return validation_2.validateAndNormalizeProps; } });
+exports.default = exports.withMappEngage;

package/plugin/build/ios.d.ts

@@ -0,0 +1,5 @@
+import { ConfigPlugin } from '@expo/config-plugins';
+import type { NormalizedMappExpoPluginProps } from './types';
+export declare function buildAppoxeeConfig(props: NormalizedMappExpoPluginProps['ios']): Record<string, unknown>;
+export declare function writeAppoxeeConfig(platformProjectRoot: string, props: NormalizedMappExpoPluginProps['ios']): Promise<string>;
+export declare const withMappEngageIos: ConfigPlugin<NormalizedMappExpoPluginProps['ios']>;

package/plugin/build/ios.js

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withMappEngageIos = void 0;
+exports.buildAppoxeeConfig = buildAppoxeeConfig;
+exports.writeAppoxeeConfig = writeAppoxeeConfig;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const config_plugins_1 = require("@expo/config-plugins");
+const plist_1 = __importDefault(require("@expo/plist"));
+const plistName = 'AppoxeeConfig.plist';
+function buildAppoxeeConfig(props) {
+    return {
+        inapp: {
+            custom_fields: props.customFields,
+            media_timeout: props.mediaTimeout,
+        },
+        sdk: {
+            app_id: props.appId,
+            dmc_system_id: props.dmcSystemId,
+            sdk_key: props.sdkKey,
+            is_eu: props.isEu,
+            jamie_url: props.inAppServerUrl,
+            open_landing_page_inside_app: props.openLandingPageInsideApp,
+            apx_open_url_internal: 'YES',
+        },
+    };
+}
+async function writeAppoxeeConfig(platformProjectRoot, props) {
+    const outputPath = path_1.default.join(platformProjectRoot, plistName);
+    await fs_1.default.promises.writeFile(outputPath, plist_1.default.build(buildAppoxeeConfig(props)));
+    return outputPath;
+}
+function appendUnique(values, value) {
+    const result = Array.isArray(values) ? values.filter(item => typeof item === 'string') : [];
+    return result.includes(value) ? result : [...result, value];
+}
+const withMappEngageIos = (config, props) => {
+    config = (0, config_plugins_1.withInfoPlist)(config, configWithPlist => {
+        configWithPlist.modResults.UIBackgroundModes = appendUnique(configWithPlist.modResults.UIBackgroundModes, 'remote-notification');
+        if (props.enableGeofencing) {
+            configWithPlist.modResults.UIBackgroundModes = appendUnique(configWithPlist.modResults.UIBackgroundModes, 'location');
+            configWithPlist.modResults.NSLocationWhenInUseUsageDescription = props.locationWhenInUsePermission;
+            configWithPlist.modResults.NSLocationAlwaysAndWhenInUseUsageDescription = props.locationAlwaysPermission;
+        }
+        return configWithPlist;
+    });
+    config = (0, config_plugins_1.withEntitlementsPlist)(config, configWithEntitlements => {
+        configWithEntitlements.modResults['aps-environment'] =
+            configWithEntitlements.modResults['aps-environment'] ?? 'development';
+        return configWithEntitlements;
+    });
+    config = (0, config_plugins_1.withDangerousMod)(config, ['ios', async (configWithFiles) => {
+            await writeAppoxeeConfig(configWithFiles.modRequest.platformProjectRoot, props);
+            return configWithFiles;
+        }]);
+    return (0, config_plugins_1.withXcodeProject)(config, configWithProject => {
+        const project = configWithProject.modResults;
+        if (!project.hasFile(plistName)) {
+            const target = config_plugins_1.IOSConfig.XcodeUtils.getApplicationNativeTarget({
+                project,
+                projectName: configWithProject.modRequest.projectName,
+            });
+            config_plugins_1.IOSConfig.XcodeUtils.addResourceFileToGroup({
+                filepath: plistName,
+                groupName: configWithProject.modRequest.projectName,
+                isBuildFile: true,
+                project,
+                targetUuid: target.uuid,
+            });
+        }
+        return configWithProject;
+    });
+};
+exports.withMappEngageIos = withMappEngageIos;

package/plugin/build/types.d.ts

@@ -0,0 +1,32 @@
+export type MappAndroidPushHandling = 'mapp' | 'custom';
+export type MappExpoPluginProps = {
+    android?: {
+        enableGeofencing?: boolean;
+        pushHandling?: MappAndroidPushHandling;
+    };
+    ios: {
+        appId: string;
+        dmcSystemId: number;
+        sdkKey: string;
+        isEu: boolean;
+        inAppServerUrl: string;
+        openLandingPageInsideApp?: boolean;
+        customFields?: string[];
+        mediaTimeout?: number;
+        enableGeofencing?: boolean;
+        locationWhenInUsePermission?: string;
+        locationAlwaysPermission?: string;
+    };
+};
+export type NormalizedMappExpoPluginProps = {
+    android: {
+        enableGeofencing: boolean;
+        pushHandling: MappAndroidPushHandling;
+    };
+    ios: MappExpoPluginProps['ios'] & {
+        openLandingPageInsideApp: boolean;
+        customFields: string[];
+        mediaTimeout: number;
+        enableGeofencing: boolean;
+    };
+};

package/plugin/build/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/plugin/build/validation.d.ts

@@ -0,0 +1,3 @@
+import type { ExpoConfig } from '@expo/config-types';
+import type { MappExpoPluginProps, NormalizedMappExpoPluginProps } from './types';
+export declare function validateAndNormalizeProps(config: ExpoConfig, props: MappExpoPluginProps): NormalizedMappExpoPluginProps;

package/plugin/build/validation.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAndNormalizeProps = validateAndNormalizeProps;
+const prefix = '[react-native-mapp-plugin]';
+function fail(property, expectation) {
+    throw new Error(`${prefix} ${property} ${expectation}. Configure it in the Mapp plugin options.`);
+}
+function nonEmptyString(value, property) {
+    if (typeof value !== 'string' || value.trim().length === 0) {
+        fail(property, 'must be a non-empty string');
+    }
+}
+function optionalBoolean(value, property) {
+    if (value !== undefined && typeof value !== 'boolean') {
+        fail(property, 'must be a boolean');
+    }
+}
+function validateAndNormalizeProps(config, props) {
+    if (!props || typeof props !== 'object') {
+        fail('plugin options', 'must be an object');
+    }
+    if (!config.android?.package) {
+        fail('expo.android.package', 'must be set to the Firebase Android application package name');
+    }
+    if (!config.ios?.bundleIdentifier) {
+        fail('expo.ios.bundleIdentifier', 'must be set to the APNs-enabled application bundle identifier');
+    }
+    const android = props.android ?? {};
+    const pushHandling = android.pushHandling ?? 'mapp';
+    if (pushHandling !== 'mapp' && pushHandling !== 'custom') {
+        fail('android.pushHandling', 'must be either "mapp" or "custom"');
+    }
+    optionalBoolean(android.enableGeofencing, 'android.enableGeofencing');
+    if (pushHandling === 'mapp' && !config.android.googleServicesFile) {
+        fail('expo.android.googleServicesFile', 'must point to the Firebase Android application google-services.json when android.pushHandling is "mapp"');
+    }
+    const ios = props.ios;
+    if (!ios || typeof ios !== 'object') {
+        fail('ios', 'must be an object');
+    }
+    nonEmptyString(ios.appId, 'ios.appId');
+    nonEmptyString(ios.sdkKey, 'ios.sdkKey');
+    nonEmptyString(ios.inAppServerUrl, 'ios.inAppServerUrl');
+    if (!Number.isInteger(ios.dmcSystemId)) {
+        fail('ios.dmcSystemId', 'must be an integer');
+    }
+    if (typeof ios.isEu !== 'boolean') {
+        fail('ios.isEu', 'must be a boolean');
+    }
+    optionalBoolean(ios.openLandingPageInsideApp, 'ios.openLandingPageInsideApp');
+    optionalBoolean(ios.enableGeofencing, 'ios.enableGeofencing');
+    if (ios.customFields !== undefined && (!Array.isArray(ios.customFields) ||
+        ios.customFields.some(field => typeof field !== 'string' || field.trim().length === 0))) {
+        fail('ios.customFields', 'must be an array of non-empty strings');
+    }
+    if (ios.mediaTimeout !== undefined && (typeof ios.mediaTimeout !== 'number' || !Number.isFinite(ios.mediaTimeout) || ios.mediaTimeout <= 0)) {
+        fail('ios.mediaTimeout', 'must be a positive number');
+    }
+    if (ios.enableGeofencing) {
+        nonEmptyString(ios.locationWhenInUsePermission, 'ios.locationWhenInUsePermission');
+        nonEmptyString(ios.locationAlwaysPermission, 'ios.locationAlwaysPermission');
+    }
+    return {
+        android: {
+            enableGeofencing: android.enableGeofencing ?? false,
+            pushHandling,
+        },
+        ios: {
+            ...ios,
+            openLandingPageInsideApp: ios.openLandingPageInsideApp ?? false,
+            customFields: ios.customFields ?? [],
+            mediaTimeout: ios.mediaTimeout ?? 5,
+            enableGeofencing: ios.enableGeofencing ?? false,
+        },
+    };
+}

package/specs/NativeRNMappPluginModule.js

@@ -14,6 +14,7 @@ export interface Spec extends TurboModule {
   setAlias(alias: string): Promise<boolean>;
   setAliasWithResend(alias: string, resendCustomAttributes: boolean): Promise<boolean>;
   getAlias(): Promise<string>;
+  /** @deprecated Use engage(...). */
   engage2(): void;
   engage(sdkKey: string, googleProjectId: string, server: string, appID: string, tenantID: string): void;
   engageTestServer(cepURl: string, sdkKey: string, googleProjectId: string, server: string, appID: string, tenantID: string): void;
@@ -38,7 +39,9 @@ export interface Spec extends TurboModule {
   removeBadgeNumber(): void;
   startGeofencing(): Promise<string>;
   stopGeofencing(): Promise<string>;
+  /** @deprecated Use startGeofencing(). */
   startGeoFencing(): void;
+  /** @deprecated Use stopGeofencing(). */
   stopGeoFencing(): void;
   fetchLatestInboxMessage(): Promise<Object>;
   fetchInboxMessage(): Promise<Array<Object>>;