react-native-notify-kit 10.3.3 → 10.4.0

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,
+};

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

@@ -0,0 +1,261 @@
+'use strict';
+
+const DEFAULT_PACKAGE_PATH_FROM_IOS = '../node_modules/react-native-notify-kit';
+const RNFB_INFO_PLIST_INPUT_PATH = '$(BUILT_PRODUCTS_DIR)/$(INFOPLIST_PATH)';
+const RNFB_POST_INSTALL_MARKER =
+  'NotifyKitNSE: avoid an Xcode build cycle between the embedded app extension';
+
+function patchPodfileForNotifyKitNse(podfileText, options) {
+  let patched = podfileText;
+  let changed = false;
+  const packagePathFromIos = options.packagePathFromIos ?? DEFAULT_PACKAGE_PATH_FROM_IOS;
+  const placement = options.placement ?? 'nested';
+  const useFrameworks = options.useFrameworks ?? false;
+
+  if (!hasUncommentedTarget(patched, options.targetName)) {
+    const withNseTarget = insertNseTarget(
+      patched,
+      options.targetName,
+      packagePathFromIos,
+      placement,
+      useFrameworks,
+    );
+    if (withNseTarget === null) {
+      return { contents: patched, didChange: changed };
+    }
+    patched = withNseTarget;
+    changed = true;
+  }
+
+  const withRnfbPatch = ensureRnfbPostInstallPatch(patched);
+  if (withRnfbPatch !== patched) {
+    patched = withRnfbPatch;
+    changed = true;
+  }
+
+  return { contents: patched, didChange: changed };
+}
+
+function insertNseTarget(content, targetName, packagePathFromIos, placement, useFrameworks) {
+  const block = buildNseTargetBlock(targetName, packagePathFromIos, placement, useFrameworks);
+
+  const targetMatch = content.match(/^target\s+['"][^'"]+['"]\s+do/m);
+  if (!targetMatch || targetMatch.index === undefined) {
+    return appendNseTarget(content, block, placement);
+  }
+
+  const targetEndIndex = findMatchingRubyBlockEnd(content, targetMatch.index);
+
+  if (targetEndIndex === -1) {
+    throw new Error(
+      "Could not locate main app target's closing 'end' in Podfile. NSE insertion aborted. " +
+        'Your Podfile may use abstract_target, unusual formatting, or nested blocks - ' +
+        'add the NSE target manually per the legacy guide.',
+    );
+  }
+
+  if (placement === 'topLevel') {
+    const insertIndex = findLineEnd(content, targetEndIndex);
+    const separator = insertIndex > 0 && content[insertIndex - 1] === '\n' ? '\n' : '\n\n';
+    return content.slice(0, insertIndex) + separator + block + content.slice(insertIndex);
+  }
+
+  const insertIndex = targetEndIndex;
+  return content.slice(0, insertIndex) + block + content.slice(insertIndex);
+}
+
+function buildNseTargetBlock(targetName, packagePathFromIos, placement, useFrameworks) {
+  if (placement === 'topLevel') {
+    const useFrameworksLine = buildUseFrameworksLine(useFrameworks);
+
+    return (
+      `target '${targetName}' do\n` +
+      useFrameworksLine +
+      `  pod 'RNNotifeeCore', :path => '${packagePathFromIos}'\n` +
+      `end\n`
+    );
+  }
+
+  return (
+    `\n  target '${targetName}' do\n` +
+    `    inherit! :search_paths\n` +
+    `    pod 'RNNotifeeCore', :path => '${packagePathFromIos}'\n` +
+    `  end\n`
+  );
+}
+
+function buildUseFrameworksLine(useFrameworks) {
+  if (useFrameworks === 'static') {
+    return `  use_frameworks! :linkage => :static\n`;
+  }
+
+  if (useFrameworks === 'dynamic') {
+    return `  use_frameworks! :linkage => :dynamic\n`;
+  }
+
+  if (useFrameworks === true) {
+    return `  use_frameworks!\n`;
+  }
+
+  return '';
+}
+
+function appendNseTarget(content, block, placement) {
+  if (placement === 'nested') {
+    return content + '\n' + block;
+  }
+
+  const separator = content.length === 0 ? '' : content.endsWith('\n') ? '\n' : '\n\n';
+  return content + separator + block;
+}
+
+function findLineEnd(content, lineStartIndex) {
+  const newlineIndex = content.indexOf('\n', lineStartIndex);
+  return newlineIndex === -1 ? content.length : newlineIndex + 1;
+}
+
+function ensureRnfbPostInstallPatch(content) {
+  if (content.includes(RNFB_POST_INSTALL_MARKER)) {
+    return content;
+  }
+
+  const postInstall = findPostInstallBlock(content);
+  if (postInstall) {
+    const snippet =
+      '\n' + buildRnfbPostInstallSnippet(postInstall.bodyIndent, postInstall.paramName);
+    return content.slice(0, postInstall.endIndex) + snippet + content.slice(postInstall.endIndex);
+  }
+
+  const separator = content.trim().length === 0 || content.endsWith('\n') ? '\n' : '\n\n';
+  return (
+    content +
+    separator +
+    'post_install do |installer|\n' +
+    buildRnfbPostInstallSnippet('  ', 'installer') +
+    'end\n'
+  );
+}
+
+function buildRnfbPostInstallSnippet(indent, installerParamName) {
+  return [
+    `${indent}# ${RNFB_POST_INSTALL_MARKER}`,
+    `${indent}# and React Native Firebase's Info.plist processing phase.`,
+    `${indent}rnfb_info_plist_input_path = '${RNFB_INFO_PLIST_INPUT_PATH}'`,
+    `${indent}rnfb_phase_names = [`,
+    `${indent}  '[RNFB] Core Configuration',`,
+    `${indent}  '[CP-User] [RNFB] Core Configuration',`,
+    `${indent}]`,
+    '',
+    `${indent}${installerParamName}.aggregate_targets.each do |aggregate_target|`,
+    `${indent}  aggregate_target.target_definition.script_phases.each do |script_phase|`,
+    `${indent}    next unless rnfb_phase_names.include?(script_phase[:name])`,
+    `${indent}    next unless script_phase[:input_files]`,
+    '',
+    `${indent}    script_phase[:input_files].delete(rnfb_info_plist_input_path)`,
+    `${indent}  end`,
+    '',
+    `${indent}  user_project = aggregate_target.user_project`,
+    `${indent}  next unless user_project`,
+    '',
+    `${indent}  rnfb_input_path_removed = false`,
+    '',
+    `${indent}  user_project.targets.each do |target|`,
+    `${indent}    target.shell_script_build_phases.each do |phase|`,
+    `${indent}      next unless rnfb_phase_names.include?(phase.name)`,
+    `${indent}      next unless phase.input_paths`,
+    '',
+    `${indent}      if phase.input_paths.delete(rnfb_info_plist_input_path)`,
+    `${indent}        rnfb_input_path_removed = true`,
+    `${indent}      end`,
+    `${indent}    end`,
+    `${indent}  end`,
+    '',
+    `${indent}  user_project.save if rnfb_input_path_removed`,
+    `${indent}end`,
+    '',
+  ].join('\n');
+}
+
+function findPostInstallBlock(content) {
+  const postInstallPattern = /^([ \t]*)post_install\s+do\s+\|([^|]+)\|\s*(?:#.*)?$/gm;
+  let match;
+
+  while ((match = postInstallPattern.exec(content)) !== null) {
+    const endIndex = findMatchingRubyBlockEnd(content, match.index);
+    if (endIndex !== -1) {
+      return {
+        bodyIndent: `${match[1]}  `,
+        endIndex,
+        paramName: match[2].trim(),
+      };
+    }
+  }
+
+  return null;
+}
+
+function findMatchingRubyBlockEnd(content, startIndex) {
+  const afterStart = content.slice(startIndex);
+  const lines = afterStart.split('\n');
+  let depth = 0;
+  let charIndex = startIndex;
+
+  for (const line of lines) {
+    const trimmed = stripRubyLineComment(line).trim();
+
+    depth += countRubyBlockOpeners(trimmed);
+
+    if (trimmed === 'end') {
+      depth--;
+      if (depth === 0) {
+        return charIndex;
+      }
+    }
+
+    charIndex += line.length + 1;
+  }
+
+  return -1;
+}
+
+function countRubyBlockOpeners(line) {
+  if (line.length === 0) {
+    return 0;
+  }
+
+  const startsWithKeywordBlock = /^(if|unless|case|begin|while|until|for|def|class|module)\b/.test(
+    line,
+  );
+  if (startsWithKeywordBlock) {
+    return 1;
+  }
+
+  if (/\bdo\b(\s*\|[^|]*\|)?\s*$/.test(line)) {
+    return 1;
+  }
+
+  return 0;
+}
+
+function stripRubyLineComment(line) {
+  return line.replace(/#.*$/, '');
+}
+
+function hasUncommentedTarget(content, targetName) {
+  const pattern = new RegExp(`target\\s+['"]${escapeRegex(targetName)}['"]`);
+  for (const line of content.split('\n')) {
+    const stripped = line.replace(/#.*$/, '');
+    if (pattern.test(stripped)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+module.exports = {
+  patchPodfileForNotifyKitNse,
+};