react-native-notify-kit 10.3.2 → 10.4.0

package/ios/RNNotifee/NotifeeExtensionHelper.h

@@ -15,13 +15,13 @@
  *
  */
 
+#import <Foundation/Foundation.h>
+
 #if __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_10_0 || \
     __MAC_OS_X_VERSION_MAX_ALLOWED >= __MAC_10_14
 #import <UserNotifications/UserNotifications.h>
 #endif
 
-#import "NotifeeCore.h"
-
 NS_ASSUME_NONNULL_BEGIN
 @interface NotifeeExtensionHelper : NSObject
 

package/ios/RNNotifee/NotifeeExtensionHelper.m

@@ -16,6 +16,7 @@
  */
 
 #import "NotifeeExtensionHelper.h"
+#import "../NotifeeCore/NotifeeCore.h"
 
 @implementation NotifeeExtensionHelper
 

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "react-native-notify-kit",
-  "version": "10.3.2",
+  "version": "10.4.0",
   "author": "Marco Crupi",
-  "description": "Maintained Notifee-compatible fork for React Native — advanced local notifications for Android & iOS.",
+  "description": "Maintained Notifee-compatible React Native notifications library for Android, iOS, FCM Mode, rich notifications, foreground services, and Expo CNG development builds.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "bin": "./cli/bin/react-native-notify-kit",
@@ -11,6 +11,8 @@
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     },
+    "./app.plugin": "./app.plugin.js",
+    "./app.plugin.js": "./app.plugin.js",
     "./server": {
       "types": "./server/dist/index.d.ts",
       "default": "./server/dist/index.js"
@@ -30,7 +32,7 @@
     "build:watch": "tsc --watch",
     "test:server": "jest --config jest.config.server.js",
     "prepare": "yarn run build",
-    "prepack": "bash ../../scripts/prepack-cli.sh",
+    "prepack": "cd ../.. && bash build_ios_core.sh && bash scripts/verify-ios-core-generation.sh && bash scripts/prepack-cli.sh",
     "postpack": "rm -rf cli",
     "prepublishOnly": "cd ../.. && yarn run build:core",
     "format:android": "google-java-format --replace -i $(find . -type f -name \"*.java\" ! -path \"*/node_modules/*\" ! -path \"*/generated/*\")",
@@ -59,8 +61,14 @@
     "xcode": "^3.0.1"
   },
   "peerDependencies": {
+    "expo": "*",
     "react-native": ">=0.73.0"
   },
+  "peerDependenciesMeta": {
+    "expo": {
+      "optional": true
+    }
+  },
   "codegenConfig": {
     "name": "NotifeeSpec",
     "type": "modules",
@@ -87,7 +95,10 @@
     "ios",
     "firebase",
     "fcm",
+    "expo",
+    "expo-cng",
     "notifee",
+    "rich-notifications",
     "notifications"
   ],
   "publishConfig": {
@@ -103,6 +114,8 @@
     "!/src/__mocks__",
     "/dist",
     "/lib",
+    "/app.plugin.js",
+    "/plugin/build",
     "/*.podspec",
     "/jest-mock.js",
     "/react-native.config.js",

package/plugin/build/android/withNotifyKitAndroidManifest.js

@@ -0,0 +1,236 @@
+'use strict';
+
+const NOTIFY_KIT_FOREGROUND_SERVICE_NAME = 'app.notifee.core.ForegroundService';
+const ANDROID_SPECIAL_USE_FGS_SUBTYPE_PROPERTY =
+  'android.app.PROPERTY_SPECIAL_USE_FGS_SUBTYPE';
+
+const ANDROID_FOREGROUND_SERVICE_PERMISSION = 'android.permission.FOREGROUND_SERVICE';
+
+const ANDROID_FOREGROUND_SERVICE_TYPE_PERMISSIONS = {
+  camera: 'android.permission.FOREGROUND_SERVICE_CAMERA',
+  connectedDevice: 'android.permission.FOREGROUND_SERVICE_CONNECTED_DEVICE',
+  dataSync: 'android.permission.FOREGROUND_SERVICE_DATA_SYNC',
+  health: 'android.permission.FOREGROUND_SERVICE_HEALTH',
+  location: 'android.permission.FOREGROUND_SERVICE_LOCATION',
+  mediaPlayback: 'android.permission.FOREGROUND_SERVICE_MEDIA_PLAYBACK',
+  mediaProjection: 'android.permission.FOREGROUND_SERVICE_MEDIA_PROJECTION',
+  microphone: 'android.permission.FOREGROUND_SERVICE_MICROPHONE',
+  phoneCall: 'android.permission.FOREGROUND_SERVICE_PHONE_CALL',
+  remoteMessaging: 'android.permission.FOREGROUND_SERVICE_REMOTE_MESSAGING',
+  specialUse: 'android.permission.FOREGROUND_SERVICE_SPECIAL_USE',
+  systemExempted: 'android.permission.FOREGROUND_SERVICE_SYSTEM_EXEMPTED',
+};
+
+function withNotifyKitAndroidManifest(config, foregroundServiceOptions) {
+  if (!foregroundServiceOptions.enabled) {
+    return config;
+  }
+
+  const { withAndroidManifest } = requireExpoConfigPlugins();
+
+  return withAndroidManifest(config, modConfig => {
+    applyNotifyKitAndroidForegroundServiceManifest(
+      modConfig.modResults,
+      foregroundServiceOptions,
+    );
+
+    return modConfig;
+  });
+}
+
+function applyNotifyKitAndroidForegroundServiceManifest(
+  androidManifest,
+  foregroundServiceOptions,
+) {
+  ensurePermission(androidManifest, ANDROID_FOREGROUND_SERVICE_PERMISSION);
+
+  for (const permission of resolveTypeSpecificPermissions(foregroundServiceOptions.types)) {
+    ensurePermission(androidManifest, permission);
+  }
+
+  const application = ensureMainApplication(androidManifest);
+  const service = ensureNotifyKitForegroundService(application);
+  service.$ = {
+    ...service.$,
+    'android:name': NOTIFY_KIT_FOREGROUND_SERVICE_NAME,
+    'android:exported': 'false',
+    'android:foregroundServiceType': foregroundServiceOptions.types.join('|'),
+  };
+
+  if (foregroundServiceOptions.types.includes('specialUse')) {
+    if (foregroundServiceOptions.specialUseSubtype === undefined) {
+      throw new Error(
+        '[react-native-notify-kit] android.foregroundService.specialUseSubtype is required when types includes specialUse.',
+      );
+    }
+
+    upsertSpecialUseProperty(service, foregroundServiceOptions.specialUseSubtype);
+  } else {
+    removeSpecialUseProperty(service);
+  }
+
+  return androidManifest;
+}
+
+function resolveTypeSpecificPermissions(types) {
+  const permissions = [];
+
+  for (const type of types) {
+    const permission = ANDROID_FOREGROUND_SERVICE_TYPE_PERMISSIONS[type];
+    if (permission !== undefined && !permissions.includes(permission)) {
+      permissions.push(permission);
+    }
+  }
+
+  return permissions;
+}
+
+function ensurePermission(androidManifest, permissionName) {
+  const manifest = ensureManifestRoot(androidManifest);
+  const permissions = ensureArrayProperty(
+    manifest,
+    'uses-permission',
+    '[react-native-notify-kit] AndroidManifest.xml uses-permission must be an array.',
+  );
+
+  const hasPermission = permissions.some(
+    permission => permission.$ && permission.$['android:name'] === permissionName,
+  );
+
+  if (!hasPermission) {
+    permissions.push({
+      $: {
+        'android:name': permissionName,
+      },
+    });
+  }
+}
+
+function ensureMainApplication(androidManifest) {
+  const manifest = ensureManifestRoot(androidManifest);
+  const applications = ensureArrayProperty(
+    manifest,
+    'application',
+    '[react-native-notify-kit] AndroidManifest.xml application must be an array.',
+  );
+
+  if (applications.length === 0) {
+    applications.push({});
+  }
+
+  return applications[0];
+}
+
+function ensureNotifyKitForegroundService(application) {
+  const services = ensureArrayProperty(
+    application,
+    'service',
+    '[react-native-notify-kit] AndroidManifest.xml application.service must be an array.',
+  );
+  const existingService = services.find(
+    service =>
+      service.$ && service.$['android:name'] === NOTIFY_KIT_FOREGROUND_SERVICE_NAME,
+  );
+
+  if (existingService !== undefined) {
+    return existingService;
+  }
+
+  const service = {
+    $: {
+      'android:name': NOTIFY_KIT_FOREGROUND_SERVICE_NAME,
+    },
+  };
+  services.push(service);
+
+  return service;
+}
+
+function upsertSpecialUseProperty(service, subtype) {
+  const properties = ensureArrayProperty(
+    service,
+    'property',
+    '[react-native-notify-kit] AndroidManifest.xml service.property must be an array.',
+  );
+  const existingProperty = properties.find(
+    property =>
+      property.$ &&
+      property.$['android:name'] === ANDROID_SPECIAL_USE_FGS_SUBTYPE_PROPERTY,
+  );
+
+  if (existingProperty !== undefined) {
+    existingProperty.$ = {
+      ...existingProperty.$,
+      'android:name': ANDROID_SPECIAL_USE_FGS_SUBTYPE_PROPERTY,
+      'android:value': subtype,
+    };
+    return;
+  }
+
+  properties.push({
+    $: {
+      'android:name': ANDROID_SPECIAL_USE_FGS_SUBTYPE_PROPERTY,
+      'android:value': subtype,
+    },
+  });
+}
+
+function removeSpecialUseProperty(service) {
+  if (service.property === undefined) {
+    return;
+  }
+
+  service.property = service.property.filter(
+    property =>
+      property.$ &&
+      property.$['android:name'] !== ANDROID_SPECIAL_USE_FGS_SUBTYPE_PROPERTY,
+  );
+
+  if (service.property.length === 0) {
+    delete service.property;
+  }
+}
+
+function ensureManifestRoot(androidManifest) {
+  if (androidManifest.manifest === undefined) {
+    androidManifest.manifest = {};
+  }
+
+  return androidManifest.manifest;
+}
+
+function ensureArrayProperty(object, key, errorMessage) {
+  const value = object[key];
+
+  if (value === undefined) {
+    const nextValue = [];
+    object[key] = nextValue;
+    return nextValue;
+  }
+
+  if (!Array.isArray(value)) {
+    throw new Error(errorMessage);
+  }
+
+  return value;
+}
+
+function requireExpoConfigPlugins() {
+  try {
+    return require('expo/config-plugins');
+  } catch (error) {
+    try {
+      return require(require.resolve('expo/config-plugins', { paths: [process.cwd()] }));
+    } catch {
+      throw error;
+    }
+  }
+}
+
+module.exports = {
+  NOTIFY_KIT_FOREGROUND_SERVICE_NAME,
+  ANDROID_SPECIAL_USE_FGS_SUBTYPE_PROPERTY,
+  withNotifyKitAndroidManifest,
+  applyNotifyKitAndroidForegroundServiceManifest,
+  resolveTypeSpecificPermissions,
+};

package/plugin/build/index.js

@@ -0,0 +1,62 @@
+'use strict';
+
+const { createRunOncePlugin } = requireExpoConfigPlugins();
+const { normalizeNotifyKitPluginOptions } = require('./options');
+const {
+  withNotifyKitAndroidManifest,
+} = require('./android/withNotifyKitAndroidManifest');
+const {
+  withNotifyKitIosNseAppExtension,
+} = require('./ios/withNotifyKitIosNseAppExtension');
+const {
+  withNotifyKitIosNseFiles,
+} = require('./ios/withNotifyKitIosNseFiles');
+const {
+  withNotifyKitIosNsePodfile,
+} = require('./ios/withNotifyKitIosNsePodfile');
+const {
+  withNotifyKitIosNseXcodeProject,
+} = require('./ios/withNotifyKitIosNseXcodeProject');
+const pkg = require('../../package.json');
+
+function withNotifyKit(config, props = {}) {
+  const options = normalizeNotifyKitPluginOptions(props);
+  const foregroundServiceOptions = options.android.foregroundService;
+  const nseOptions = options.ios.notificationServiceExtension;
+  const configWithAndroidManifest = withNotifyKitAndroidManifest(
+    config,
+    foregroundServiceOptions,
+  );
+  const configWithAppExtension = withNotifyKitIosNseAppExtension(
+    configWithAndroidManifest,
+    nseOptions,
+  );
+  const configWithFiles = withNotifyKitIosNseFiles(configWithAppExtension, nseOptions);
+  const configWithXcodeProject = withNotifyKitIosNseXcodeProject(configWithFiles, nseOptions);
+
+  return withNotifyKitIosNsePodfile(configWithXcodeProject, nseOptions);
+}
+
+const plugin = createRunOncePlugin(withNotifyKit, pkg.name, pkg.version);
+
+module.exports = plugin;
+module.exports.default = plugin;
+module.exports.withNotifyKit = withNotifyKit;
+module.exports.normalizeNotifyKitPluginOptions = normalizeNotifyKitPluginOptions;
+module.exports.withNotifyKitAndroidManifest = withNotifyKitAndroidManifest;
+module.exports.withNotifyKitIosNseAppExtension = withNotifyKitIosNseAppExtension;
+module.exports.withNotifyKitIosNseFiles = withNotifyKitIosNseFiles;
+module.exports.withNotifyKitIosNseXcodeProject = withNotifyKitIosNseXcodeProject;
+module.exports.withNotifyKitIosNsePodfile = withNotifyKitIosNsePodfile;
+
+function requireExpoConfigPlugins() {
+  try {
+    return require('expo/config-plugins');
+  } catch (error) {
+    try {
+      return require(require.resolve('expo/config-plugins', { paths: [process.cwd()] }));
+    } catch {
+      throw error;
+    }
+  }
+}

package/plugin/build/ios/withNotifyKitIosNseAppExtension.js

@@ -0,0 +1,142 @@
+'use strict';
+
+function withNotifyKitIosNseAppExtension(config, nseOptions) {
+  if (!nseOptions.enabled) {
+    return config;
+  }
+
+  const bundleIdentifier = resolveNotifyKitIosNseBundleIdentifier(config, nseOptions);
+  const currentAppExtensions = getCurrentAppExtensions(config);
+  const nextAppExtensions = upsertNotifyKitIosNseAppExtension(currentAppExtensions, {
+    targetName: nseOptions.targetName,
+    bundleIdentifier,
+  });
+
+  return {
+    ...config,
+    extra: setNestedAppExtensions(config.extra, nextAppExtensions),
+  };
+}
+
+function resolveNotifyKitIosNseBundleIdentifier(config, nseOptions) {
+  const hostBundleIdentifier = config.ios && config.ios.bundleIdentifier;
+  if (!hostBundleIdentifier) {
+    throw new Error(
+      '[react-native-notify-kit] ios.bundleIdentifier is required when ios.notificationServiceExtension.enabled is true.',
+    );
+  }
+
+  return `${hostBundleIdentifier}${nseOptions.bundleSuffix}`;
+}
+
+function upsertNotifyKitIosNseAppExtension(appExtensions, nextExtension) {
+  const nextAppExtensions = [];
+  let didUpsert = false;
+
+  for (const appExtension of appExtensions) {
+    if (!isPlainObject(appExtension)) {
+      throw new Error(
+        '[react-native-notify-kit] extra.eas.build.experimental.ios.appExtensions must contain objects.',
+      );
+    }
+
+    if (appExtension.targetName === nextExtension.targetName) {
+      if (
+        appExtension.bundleIdentifier !== undefined &&
+        appExtension.bundleIdentifier !== nextExtension.bundleIdentifier
+      ) {
+        throw new Error(
+          `[react-native-notify-kit] EAS app extension targetName '${nextExtension.targetName}' already uses bundleIdentifier '${appExtension.bundleIdentifier}'. ` +
+            `Expected '${nextExtension.bundleIdentifier}'.`,
+        );
+      }
+
+      if (!didUpsert) {
+        nextAppExtensions.push({
+          ...appExtension,
+          targetName: nextExtension.targetName,
+          bundleIdentifier: nextExtension.bundleIdentifier,
+        });
+        didUpsert = true;
+      }
+      continue;
+    }
+
+    if (appExtension.bundleIdentifier === nextExtension.bundleIdentifier) {
+      throw new Error(
+        `[react-native-notify-kit] EAS app extension bundleIdentifier '${nextExtension.bundleIdentifier}' already belongs to targetName '${appExtension.targetName}'. ` +
+          `Expected '${nextExtension.targetName}'.`,
+      );
+    }
+
+    nextAppExtensions.push(appExtension);
+  }
+
+  if (!didUpsert) {
+    nextAppExtensions.push({
+      targetName: nextExtension.targetName,
+      bundleIdentifier: nextExtension.bundleIdentifier,
+    });
+  }
+
+  return nextAppExtensions;
+}
+
+function getCurrentAppExtensions(config) {
+  const appExtensions = getObject(config.extra)?.eas;
+  const build = getObject(appExtensions)?.build;
+  const experimental = getObject(build)?.experimental;
+  const ios = getObject(experimental)?.ios;
+  const currentAppExtensions = getObject(ios)?.appExtensions;
+
+  if (currentAppExtensions === undefined) {
+    return [];
+  }
+
+  if (!Array.isArray(currentAppExtensions)) {
+    throw new Error(
+      '[react-native-notify-kit] extra.eas.build.experimental.ios.appExtensions must be an array.',
+    );
+  }
+
+  return currentAppExtensions;
+}
+
+function setNestedAppExtensions(currentExtra, appExtensions) {
+  const extra = getObject(currentExtra) ?? {};
+  const eas = getObject(extra.eas) ?? {};
+  const build = getObject(eas.build) ?? {};
+  const experimental = getObject(build.experimental) ?? {};
+  const ios = getObject(experimental.ios) ?? {};
+
+  return {
+    ...extra,
+    eas: {
+      ...eas,
+      build: {
+        ...build,
+        experimental: {
+          ...experimental,
+          ios: {
+            ...ios,
+            appExtensions,
+          },
+        },
+      },
+    },
+  };
+}
+
+function getObject(value) {
+  return isPlainObject(value) ? value : null;
+}
+
+function isPlainObject(value) {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+module.exports = {
+  withNotifyKitIosNseAppExtension,
+  resolveNotifyKitIosNseBundleIdentifier,
+  upsertNotifyKitIosNseAppExtension,
+};

package/plugin/build/ios/withNotifyKitIosNseFiles.js

@@ -0,0 +1,79 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const {
+  renderNotificationServiceSwift,
+  renderNseEntitlementsPlist,
+  renderNseInfoPlist,
+} = require('../shared/nse/initNseCore');
+
+function withNotifyKitIosNseFiles(config, nseOptions) {
+  if (!nseOptions.enabled) {
+    return config;
+  }
+
+  const { withDangerousMod } = requireExpoConfigPlugins();
+
+  return withDangerousMod(config, [
+    'ios',
+    modConfig => {
+      writeNotifyKitIosNseFiles(
+        modConfig.modRequest.platformProjectRoot,
+        nseOptions.targetName,
+      );
+      return modConfig;
+    },
+  ]);
+}
+
+function writeNotifyKitIosNseFiles(platformProjectRoot, targetName) {
+  const targetDir = path.join(platformProjectRoot, targetName);
+  fs.mkdirSync(targetDir, { recursive: true });
+
+  writeFileIfMissingOrIdentical(
+    path.join(targetDir, 'NotificationService.swift'),
+    renderNotificationServiceSwift(),
+  );
+  writeFileIfMissingOrIdentical(
+    path.join(targetDir, 'Info.plist'),
+    renderNseInfoPlist({ targetName }),
+  );
+  writeFileIfMissingOrIdentical(
+    path.join(targetDir, `${targetName}.entitlements`),
+    renderNseEntitlementsPlist(),
+  );
+}
+
+function writeFileIfMissingOrIdentical(filePath, contents) {
+  if (fs.existsSync(filePath)) {
+    const currentContents = fs.readFileSync(filePath, 'utf8');
+    if (currentContents !== contents) {
+      throw new Error(
+        `[react-native-notify-kit] Refusing to overwrite existing ${filePath}. ` +
+          'Delete it or make it match the generated NotifyKit NSE template.',
+      );
+    }
+    return;
+  }
+
+  fs.writeFileSync(filePath, contents, 'utf8');
+}
+
+function requireExpoConfigPlugins() {
+  try {
+    return require('expo/config-plugins');
+  } catch (error) {
+    try {
+      return require(require.resolve('expo/config-plugins', { paths: [process.cwd()] }));
+    } catch {
+      throw error;
+    }
+  }
+}
+
+module.exports = {
+  withNotifyKitIosNseFiles,
+  writeNotifyKitIosNseFiles,
+};