react-native-notify-kit 10.3.2 → 10.4.0

package/plugin/build/ios/withNotifyKitIosNsePodfile.js

@@ -0,0 +1,130 @@
+'use strict';
+
+const path = require('path');
+
+const { patchPodfileForNotifyKitNse } = require('../shared/nse/patchPodfile');
+
+function withNotifyKitIosNsePodfile(config, nseOptions) {
+  if (!nseOptions.enabled) {
+    return config;
+  }
+
+  const { withPodfile } = requireExpoConfigPlugins();
+  const configuredUseFrameworks = detectConfiguredExpoBuildPropertiesUseFrameworks(config);
+
+  return withPodfile(config, modConfig => {
+    const { projectRoot, platformProjectRoot } = modConfig.modRequest;
+    const packagePathFromIos = resolveNotifyKitPackagePathFromIos(
+      projectRoot,
+      platformProjectRoot,
+    );
+    const hostUseFrameworks = detectPodfileUseFrameworks(modConfig.modResults.contents);
+    const useFrameworks = resolveNseUseFrameworks(hostUseFrameworks, configuredUseFrameworks);
+    const result = patchPodfileForNotifyKitNse(modConfig.modResults.contents, {
+      targetName: nseOptions.targetName,
+      packagePathFromIos,
+      placement: 'topLevel',
+      useFrameworks,
+    });
+
+    modConfig.modResults.contents = result.contents;
+    return modConfig;
+  });
+}
+
+function resolveNotifyKitPackagePathFromIos(projectRoot, platformProjectRoot) {
+  const packageJsonPath = require.resolve('react-native-notify-kit/package.json', {
+    paths: [projectRoot],
+  });
+  const packageDir = path.dirname(packageJsonPath);
+
+  return normalizePodfilePath(path.relative(platformProjectRoot, packageDir));
+}
+
+function normalizePodfilePath(filePath) {
+  return filePath.replace(/\\/g, '/');
+}
+
+function detectPodfileUseFrameworks(contents) {
+  let detected = false;
+
+  for (const line of contents.split('\n')) {
+    const stripped = line.replace(/#.*$/, '').trim();
+    if (!/^use_frameworks!(?:\s|$)/.test(stripped)) {
+      continue;
+    }
+
+    if (/:linkage\s*=>\s*:static\b/.test(stripped) || /\blinkage:\s*:static\b/.test(stripped)) {
+      return 'static';
+    }
+
+    if (
+      /:linkage\s*=>\s*:dynamic\b/.test(stripped) ||
+      /\blinkage:\s*:dynamic\b/.test(stripped)
+    ) {
+      return 'dynamic';
+    }
+
+    detected = true;
+  }
+
+  return detected;
+}
+
+function resolveNseUseFrameworks(hostUseFrameworks, configuredUseFrameworks) {
+  if (hostUseFrameworks === false) {
+    return false;
+  }
+
+  if (hostUseFrameworks === true && configuredUseFrameworks !== false) {
+    return configuredUseFrameworks;
+  }
+
+  return hostUseFrameworks;
+}
+
+function detectConfiguredExpoBuildPropertiesUseFrameworks(config) {
+  const plugins = Array.isArray(config.plugins) ? config.plugins : [];
+  let detected = false;
+
+  for (const plugin of plugins) {
+    if (!Array.isArray(plugin) || plugin[0] !== 'expo-build-properties') {
+      continue;
+    }
+
+    const options = isPlainObject(plugin[1]) ? plugin[1] : null;
+    const ios = isPlainObject(options?.ios) ? options.ios : null;
+    const useFrameworks = ios?.useFrameworks;
+
+    if (useFrameworks === 'static' || useFrameworks === 'dynamic') {
+      detected = useFrameworks;
+    } else if (useFrameworks === true || useFrameworks === false) {
+      detected = useFrameworks;
+    }
+  }
+
+  return detected;
+}
+
+function isPlainObject(value) {
+  return typeof value === 'object' && value !== null && !Array.isArray(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 = {
+  withNotifyKitIosNsePodfile,
+  resolveNotifyKitPackagePathFromIos,
+  normalizePodfilePath,
+  detectPodfileUseFrameworks,
+};

package/plugin/build/ios/withNotifyKitIosNseXcodeProject.js

@@ -0,0 +1,49 @@
+'use strict';
+
+const {
+  patchXcodeProjectForNotifyKitNse,
+} = require('../shared/nse/patchXcodeProject');
+const {
+  resolveNotifyKitIosNseBundleIdentifier,
+} = require('./withNotifyKitIosNseAppExtension');
+
+function withNotifyKitIosNseXcodeProject(config, nseOptions) {
+  if (!nseOptions.enabled) {
+    return config;
+  }
+
+  const { withXcodeProject } = requireExpoConfigPlugins();
+  const bundleIdentifier = resolveNotifyKitIosNseBundleIdentifier(config, nseOptions);
+
+  return withXcodeProject(config, modConfig => {
+    const result = patchXcodeProjectForNotifyKitNse(modConfig.modResults, {
+      targetName: nseOptions.targetName,
+      bundleIdentifier,
+      parentTargetName: modConfig.modRequest.projectName,
+    });
+
+    if (result.didChange && !result.hostTargetUuid) {
+      throw new Error(
+        '[react-native-notify-kit] Failed to link NotifyKit NSE target to the host app target.',
+      );
+    }
+
+    return modConfig;
+  });
+}
+
+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 = {
+  withNotifyKitIosNseXcodeProject,
+};

package/plugin/build/options.js

@@ -0,0 +1,224 @@
+'use strict';
+
+const DEFAULT_IOS_NSE_TARGET_NAME = 'NotifyKitNSE';
+const DEFAULT_IOS_NSE_BUNDLE_SUFFIX = '.NotifyKitNSE';
+
+const ANDROID_FOREGROUND_SERVICE_TYPES = [
+  'camera',
+  'connectedDevice',
+  'dataSync',
+  'health',
+  'location',
+  'mediaPlayback',
+  'mediaProjection',
+  'microphone',
+  'phoneCall',
+  'remoteMessaging',
+  'shortService',
+  'specialUse',
+  'systemExempted',
+];
+
+const TARGET_NAME_PATTERN = /^[A-Za-z0-9_\-.]+$/;
+const BUNDLE_SUFFIX_PATTERN = /^\.[A-Za-z0-9\-.]+$/;
+
+function normalizeNotifyKitPluginOptions(options = {}) {
+  return {
+    ios: {
+      notificationServiceExtension: normalizeIosNotificationServiceExtensionOptions(
+        options.ios && options.ios.notificationServiceExtension,
+      ),
+    },
+    android: {
+      foregroundService: normalizeAndroidForegroundServiceOptions(
+        options.android && options.android.foregroundService,
+      ),
+    },
+  };
+}
+
+function normalizeIosNotificationServiceExtensionOptions(input) {
+  if (input === undefined || input === false) {
+    return disabledIosNotificationServiceExtensionOptions();
+  }
+
+  if (input === true) {
+    return validateEnabledIosNotificationServiceExtensionOptions({
+      enabled: true,
+      targetName: DEFAULT_IOS_NSE_TARGET_NAME,
+      bundleSuffix: DEFAULT_IOS_NSE_BUNDLE_SUFFIX,
+    });
+  }
+
+  if (!isPlainObject(input)) {
+    throw new Error(
+      '[react-native-notify-kit] ios.notificationServiceExtension must be a boolean or an object.',
+    );
+  }
+
+  if (input.enabled !== undefined && typeof input.enabled !== 'boolean') {
+    throw new Error(
+      '[react-native-notify-kit] ios.notificationServiceExtension.enabled must be a boolean.',
+    );
+  }
+
+  if (input.enabled !== true) {
+    return disabledIosNotificationServiceExtensionOptions();
+  }
+
+  return validateEnabledIosNotificationServiceExtensionOptions({
+    enabled: true,
+    targetName: input.targetName ?? DEFAULT_IOS_NSE_TARGET_NAME,
+    bundleSuffix: input.bundleSuffix ?? DEFAULT_IOS_NSE_BUNDLE_SUFFIX,
+  });
+}
+
+function disabledIosNotificationServiceExtensionOptions() {
+  return {
+    enabled: false,
+    targetName: DEFAULT_IOS_NSE_TARGET_NAME,
+    bundleSuffix: DEFAULT_IOS_NSE_BUNDLE_SUFFIX,
+  };
+}
+
+function validateEnabledIosNotificationServiceExtensionOptions(options) {
+  if (typeof options.targetName !== 'string' || options.targetName.length === 0) {
+    throw new Error(
+      '[react-native-notify-kit] ios.notificationServiceExtension.targetName must be a non-empty string.',
+    );
+  }
+
+  if (!TARGET_NAME_PATTERN.test(options.targetName)) {
+    throw new Error(
+      `[react-native-notify-kit] Invalid notification service extension targetName '${options.targetName}'. ` +
+        'Use only letters, digits, underscores, hyphens, and dots.',
+    );
+  }
+
+  if (typeof options.bundleSuffix !== 'string' || options.bundleSuffix.length === 0) {
+    throw new Error(
+      '[react-native-notify-kit] ios.notificationServiceExtension.bundleSuffix must be a non-empty string.',
+    );
+  }
+
+  if (!BUNDLE_SUFFIX_PATTERN.test(options.bundleSuffix)) {
+    throw new Error(
+      `[react-native-notify-kit] Invalid notification service extension bundleSuffix '${options.bundleSuffix}'. ` +
+        "It must start with '.' and contain only letters, digits, hyphens, and dots.",
+    );
+  }
+
+  return options;
+}
+
+function normalizeAndroidForegroundServiceOptions(input) {
+  if (input === undefined) {
+    return disabledAndroidForegroundServiceOptions();
+  }
+
+  if (!isPlainObject(input)) {
+    throw new Error(
+      '[react-native-notify-kit] android.foregroundService must be an object with a non-empty types array.',
+    );
+  }
+
+  const types = normalizeAndroidForegroundServiceTypes(input.types);
+  const specialUseSubtype = normalizeSpecialUseSubtype(input.specialUseSubtype);
+  const hasSpecialUse = types.includes('specialUse');
+
+  if (hasSpecialUse && specialUseSubtype === undefined) {
+    throw new Error(
+      '[react-native-notify-kit] android.foregroundService.specialUseSubtype must be a non-empty string when types includes specialUse.',
+    );
+  }
+
+  if (!hasSpecialUse && specialUseSubtype !== undefined) {
+    throw new Error(
+      '[react-native-notify-kit] android.foregroundService.specialUseSubtype requires types to include specialUse.',
+    );
+  }
+
+  return {
+    enabled: true,
+    types,
+    ...(specialUseSubtype === undefined ? {} : { specialUseSubtype }),
+  };
+}
+
+function disabledAndroidForegroundServiceOptions() {
+  return {
+    enabled: false,
+    types: [],
+  };
+}
+
+function normalizeAndroidForegroundServiceTypes(input) {
+  if (!Array.isArray(input)) {
+    throw new Error(
+      '[react-native-notify-kit] android.foregroundService.types must be a non-empty array.',
+    );
+  }
+
+  if (input.length === 0) {
+    throw new Error(
+      '[react-native-notify-kit] android.foregroundService.types must be a non-empty array.',
+    );
+  }
+
+  const seen = new Set();
+  const types = [];
+
+  for (const value of input) {
+    if (typeof value !== 'string') {
+      throw new Error(
+        '[react-native-notify-kit] android.foregroundService.types must contain only strings.',
+      );
+    }
+
+    const type = value.trim();
+    if (!isAndroidForegroundServiceType(type)) {
+      throw new Error(
+        `[react-native-notify-kit] Invalid android.foregroundService type '${value}'. ` +
+          `Allowed values: ${ANDROID_FOREGROUND_SERVICE_TYPES.join(', ')}.`,
+      );
+    }
+
+    if (!seen.has(type)) {
+      seen.add(type);
+      types.push(type);
+    }
+  }
+
+  return types;
+}
+
+function normalizeSpecialUseSubtype(input) {
+  if (input === undefined) {
+    return undefined;
+  }
+
+  if (typeof input !== 'string' || input.trim().length === 0) {
+    throw new Error(
+      '[react-native-notify-kit] android.foregroundService.specialUseSubtype must be a non-empty string.',
+    );
+  }
+
+  return input.trim();
+}
+
+function isAndroidForegroundServiceType(value) {
+  return ANDROID_FOREGROUND_SERVICE_TYPES.includes(value);
+}
+
+function isPlainObject(value) {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+module.exports = {
+  DEFAULT_IOS_NSE_TARGET_NAME,
+  DEFAULT_IOS_NSE_BUNDLE_SUFFIX,
+  ANDROID_FOREGROUND_SERVICE_TYPES,
+  normalizeNotifyKitPluginOptions,
+  normalizeIosNotificationServiceExtensionOptions,
+  normalizeAndroidForegroundServiceOptions,
+};

package/plugin/build/shared/nse/index.js

@@ -0,0 +1,7 @@
+'use strict';
+
+module.exports = {
+  ...require('./initNseCore'),
+  ...require('./patchPodfile'),
+  ...require('./patchXcodeProject'),
+};

package/plugin/build/shared/nse/initNseCore.js

@@ -0,0 +1,220 @@
+'use strict';
+
+const NSE_TARGET_NAME_PATTERN = /^[A-Za-z0-9_\-.]+$/;
+const NSE_BUNDLE_SUFFIX_PATTERN = /^\.[A-Za-z0-9\-.]+$/;
+
+const PRODUCT_BUNDLE_IDENTIFIER_PLACEHOLDER = '$(PRODUCT_BUNDLE_IDENTIFIER:default)';
+
+const NOTIFICATION_SERVICE_SWIFT = String.raw`import Foundation
+import UserNotifications
+import RNNotifeeCore
+
+private func nseLog(_ message: String) {
+  NSLog("[NotifyKitNSE] %@", message)
+}
+
+private func requestedAttachmentURLs(from userInfo: [AnyHashable: Any]) -> [String] {
+  guard let serializedOptions = userInfo["notifee_options"] as? String,
+        let data = serializedOptions.data(using: .utf8),
+        let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
+        let ios = json["ios"] as? [String: Any],
+        let attachments = ios["attachments"] as? [[String: Any]] else {
+    return []
+  }
+
+  return attachments.compactMap { attachment in
+    attachment["url"] as? String
+  }
+}
+
+class NotificationService: UNNotificationServiceExtension {
+  var contentHandler: ((UNNotificationContent) -> Void)?
+  var bestAttemptContent: UNMutableNotificationContent?
+  private let deliveryLock = NSLock()
+  private var didDeliver = false
+
+  override func didReceive(
+    _ request: UNNotificationRequest,
+    withContentHandler contentHandler: @escaping (UNNotificationContent) -> Void
+  ) {
+    let mutableContent = request.content.mutableCopy() as? UNMutableNotificationContent
+
+    deliveryLock.lock()
+    didDeliver = false
+    self.contentHandler = contentHandler
+    self.bestAttemptContent = mutableContent
+    deliveryLock.unlock()
+
+    let requestedAttachmentUrls = requestedAttachmentURLs(from: request.content.userInfo)
+
+    nseLog(
+      "didReceive id=\(request.identifier) title=\(request.content.title) " +
+        "hasNotifeeOptions=\(request.content.userInfo["notifee_options"] != nil) " +
+        "requestedAttachments=\(requestedAttachmentUrls.count) " +
+        "urls=\(requestedAttachmentUrls.joined(separator: ","))"
+    )
+
+    guard let bestAttemptContent = mutableContent else {
+      nseLog("mutableCopy failed for id=\(request.identifier); delivering original content")
+      deliverOnce(request.content)
+      return
+    }
+
+    NotifeeExtensionHelper.populateNotificationContent(
+      request,
+      with: bestAttemptContent,
+      withContentHandler: { [weak self] content in
+        let deliveredAttachmentIds = content.attachments.map(\.identifier).joined(separator: ",")
+        nseLog(
+          "contentHandler id=\(request.identifier) title=\(content.title) " +
+            "deliveredAttachments=\(content.attachments.count) " +
+            "identifiers=\(deliveredAttachmentIds)"
+        )
+        self?.deliverOnce(content)
+      }
+    )
+  }
+
+  private func deliverOnce(_ content: UNNotificationContent) {
+    var handler: ((UNNotificationContent) -> Void)?
+
+    deliveryLock.lock()
+    if !didDeliver {
+      didDeliver = true
+      handler = contentHandler
+      contentHandler = nil
+      bestAttemptContent = nil
+    }
+    deliveryLock.unlock()
+
+    handler?(content)
+  }
+
+  override func serviceExtensionTimeWillExpire() {
+    deliveryLock.lock()
+    let content = bestAttemptContent
+    deliveryLock.unlock()
+
+    if let bestAttemptContent = content {
+      nseLog(
+        "serviceExtensionTimeWillExpire id=\(bestAttemptContent.userInfo["gcm.message_id"] ?? "n/a") " +
+          "title=\(bestAttemptContent.title) " +
+          "deliveredAttachments=\(bestAttemptContent.attachments.count)"
+      )
+      deliverOnce(bestAttemptContent)
+    }
+  }
+}
+`;
+
+const NSE_INFO_PLIST_TEMPLATE = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+\t<key>CFBundleDisplayName</key>
+\t<string>{{TARGET_NAME}}</string>
+\t<key>CFBundleExecutable</key>
+\t<string>$(EXECUTABLE_NAME)</string>
+\t<key>CFBundleIdentifier</key>
+\t<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
+\t<key>CFBundleInfoDictionaryVersion</key>
+\t<string>6.0</string>
+\t<key>CFBundleName</key>
+\t<string>$(PRODUCT_NAME)</string>
+\t<key>CFBundlePackageType</key>
+\t<string>$(PRODUCT_BUNDLE_PACKAGE_TYPE)</string>
+\t<key>CFBundleShortVersionString</key>
+\t<string>1.0</string>
+\t<key>CFBundleVersion</key>
+\t<string>1</string>
+\t<key>NSExtension</key>
+\t<dict>
+\t\t<key>NSExtensionPointIdentifier</key>
+\t\t<string>com.apple.usernotifications.service</string>
+\t\t<key>NSExtensionPrincipalClass</key>
+\t\t<string>$(PRODUCT_MODULE_NAME).NotificationService</string>
+\t</dict>
+</dict>
+</plist>
+`;
+
+const NSE_ENTITLEMENTS_PLIST = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+</dict>
+</plist>
+`;
+
+function validateNseTargetName(targetName) {
+  if (!NSE_TARGET_NAME_PATTERN.test(targetName)) {
+    throw new Error(
+      `Invalid target name '${targetName}'. Must match [A-Za-z0-9_-.]\n` +
+        '  Target names can only contain letters, digits, underscores, hyphens, and dots.',
+    );
+  }
+}
+
+function validateNseBundleSuffix(bundleSuffix) {
+  if (!NSE_BUNDLE_SUFFIX_PATTERN.test(bundleSuffix)) {
+    throw new Error(
+      `Invalid bundle suffix '${bundleSuffix}'. Must start with '.' and contain only letters, digits, hyphens, and dots.`,
+    );
+  }
+}
+
+function deriveNseBundleIdentifier(parentBundleId, suffix, parentTargetName) {
+  if (!parentBundleId) {
+    return `${PRODUCT_BUNDLE_IDENTIFIER_PLACEHOLDER}${suffix}`;
+  }
+
+  if (!parentBundleId.includes('$(') && !parentBundleId.includes('${')) {
+    return parentBundleId + suffix;
+  }
+
+  const expandedBundleId = expandKnownBundleIdVariables(parentBundleId, parentTargetName);
+  if (expandedBundleId && !expandedBundleId.includes('$(') && !expandedBundleId.includes('${')) {
+    return expandedBundleId + suffix;
+  }
+
+  return `${PRODUCT_BUNDLE_IDENTIFIER_PLACEHOLDER}${suffix}`;
+}
+
+function renderNotificationServiceSwift() {
+  return NOTIFICATION_SERVICE_SWIFT;
+}
+
+function renderNseInfoPlist(options) {
+  return NSE_INFO_PLIST_TEMPLATE.replace(/\{\{TARGET_NAME\}\}/g, options.targetName);
+}
+
+function renderNseEntitlementsPlist() {
+  return NSE_ENTITLEMENTS_PLIST;
+}
+
+function expandKnownBundleIdVariables(bundleId, parentTargetName) {
+  if (!parentTargetName) {
+    return null;
+  }
+
+  const normalizedTargetName = toRfc1034Identifier(parentTargetName);
+
+  return bundleId
+    .replace(/\$\((?:PRODUCT_NAME|TARGET_NAME):rfc1034identifier\)/g, normalizedTargetName)
+    .replace(/\$\{(?:PRODUCT_NAME|TARGET_NAME):rfc1034identifier\}/g, normalizedTargetName)
+    .replace(/\$\((?:PRODUCT_NAME|TARGET_NAME)\)/g, parentTargetName)
+    .replace(/\$\{(?:PRODUCT_NAME|TARGET_NAME)\}/g, parentTargetName);
+}
+
+function toRfc1034Identifier(value) {
+  return value.replace(/[^A-Za-z0-9.-]/g, '-');
+}
+
+module.exports = {
+  deriveNseBundleIdentifier,
+  renderNotificationServiceSwift,
+  renderNseEntitlementsPlist,
+  renderNseInfoPlist,
+  validateNseBundleSuffix,
+  validateNseTargetName,
+};