react-native-notify-kit 10.10.0 → 10.10.1

package/plugin/build/ios/withNotifyKitIosNsePodfile.js

@@ -1,52 +1,54 @@
 'use strict';
-
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.withNotifyKitIosNsePodfile = withNotifyKitIosNsePodfile;
+exports.resolveNotifyKitPackagePathFromIos = resolveNotifyKitPackagePathFromIos;
+exports.normalizePodfilePath = normalizePodfilePath;
+exports.detectPodfileUseFrameworks = detectPodfileUseFrameworks;
 const fs = require('fs');
 const path = require('path');
-
-const { patchPodfileForNotifyKitNse } = require('../shared/nse/patchPodfile');
-
+const patchPodfile_1 = 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);
+    // Podfile mods can run before expo-build-properties writes its properties
+    // mod. Read the configuration that the host will consume at pod install,
+    // rather than a missing/stale file left by a clean/incremental prebuild.
+    const podfileProperties = readExpoPodfileProperties(platformProjectRoot);
+    if (configuredUseFrameworks === 'static' || configuredUseFrameworks === 'dynamic') {
+      podfileProperties['ios.useFrameworks'] = configuredUseFrameworks;
+    }
     const hostUseFrameworks = detectPodfileUseFrameworks(modConfig.modResults.contents, {
       ignoredTargetName: nseOptions.targetName,
-      podfileProperties: readExpoPodfileProperties(platformProjectRoot),
+      podfileProperties,
       env: process.env,
     });
     const useFrameworks = resolveNseUseFrameworks(hostUseFrameworks, configuredUseFrameworks);
-    const result = patchPodfileForNotifyKitNse(modConfig.modResults.contents, {
+    const result = (0, patchPodfile_1.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, optionsOrIgnoredTargetName) {
   const options =
     typeof optionsOrIgnoredTargetName === 'string'
@@ -59,30 +61,24 @@ function detectPodfileUseFrameworks(contents, optionsOrIgnoredTargetName) {
   let globalUseFrameworks = false;
   let hostUseFrameworks = false;
   let charIndex = 0;
-
   for (const line of contents.split('\n')) {
     const detectedUseFrameworks = parseUseFrameworksLine(line, options);
     if (detectedUseFrameworks === null) {
       charIndex += line.length + 1;
       continue;
     }
-
     const targetBlock = findMostSpecificTargetBlock(targetBlocks, charIndex);
     if (!targetBlock) {
       globalUseFrameworks = mergeUseFrameworksDetection(globalUseFrameworks, detectedUseFrameworks);
     } else if (targetBlock === firstHostTarget) {
       hostUseFrameworks = mergeUseFrameworksDetection(hostUseFrameworks, detectedUseFrameworks);
     }
-
     charIndex += line.length + 1;
   }
-
   return hostUseFrameworks !== false ? hostUseFrameworks : globalUseFrameworks;
 }
-
 function readExpoPodfileProperties(platformProjectRoot) {
   const propertiesPath = path.join(platformProjectRoot, 'Podfile.properties.json');
-
   try {
     const parsed = JSON.parse(fs.readFileSync(propertiesPath, 'utf8'));
     return isPlainObject(parsed) ? parsed : {};
@@ -90,240 +86,186 @@ function readExpoPodfileProperties(platformProjectRoot) {
     if (isFileNotFoundError(error)) {
       return {};
     }
-
     throw error;
   }
 }
-
 function isFileNotFoundError(error) {
   return isPlainObject(error) && error.code === 'ENOENT';
 }
-
 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 findTargetBlocks(contents) {
   const targetPattern = /^[ \t]*target\s+['"]([^'"]+)['"]\s+do\b.*$/gm;
   const blocks = [];
   let match;
-
   while ((match = targetPattern.exec(contents)) !== null) {
     const endLineStart = findMatchingRubyBlockEnd(contents, match.index);
     if (endLineStart === -1) {
       continue;
     }
-
     blocks.push({
       targetName: match[1],
       startIndex: match.index,
       endIndex: findLineEnd(contents, endLineStart),
     });
   }
-
   return blocks;
 }
-
 function findMostSpecificTargetBlock(targetBlocks, charIndex) {
   return targetBlocks
     .filter(block => charIndex >= block.startIndex && charIndex < block.endIndex)
     .sort((a, b) => b.startIndex - a.startIndex)[0];
 }
-
 function parseUseFrameworksLine(line, options) {
   const stripped = stripRubyLineComment(line).trim();
   if (!/^use_frameworks!(?:\s|$)/.test(stripped)) {
     return null;
   }
-
   if (!isUseFrameworksConditionActive(stripped, options)) {
     return null;
   }
-
   const podfilePropertyLinkage = getPodfilePropertyUseFrameworksLinkage(stripped, options);
   if (podfilePropertyLinkage !== null) {
     return podfilePropertyLinkage;
   }
-
   const envLinkage = getEnvUseFrameworksLinkage(stripped, options);
   if (envLinkage !== null) {
     return envLinkage;
   }
-
   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';
   }
-
   return true;
 }
-
 function mergeUseFrameworksDetection(current, detected) {
   return detected;
 }
-
 function isUseFrameworksConditionActive(strippedLine, options) {
   const condition = strippedLine.match(/\s+if\s+(.+)$/)?.[1]?.trim();
   if (!condition) {
     return true;
   }
-
   const podfilePropertyName = getPodfilePropertyName(condition);
   if (podfilePropertyName !== null) {
     return isRubyTruthy(options.podfileProperties?.[podfilePropertyName]);
   }
-
   const envName = getEnvName(condition);
   if (envName !== null) {
     return isRubyTruthy(options.env?.[envName]);
   }
-
   return true;
 }
-
 function getPodfilePropertyUseFrameworksLinkage(strippedLine, options) {
   const propertyName = strippedLine.match(
     /(?:\:linkage\s*=>|linkage:)\s*podfile_properties\[['"]([^'"]+)['"]\](?:\.to_sym)?/,
   )?.[1];
-
   return propertyName
     ? normalizeUseFrameworksValue(options.podfileProperties?.[propertyName])
     : null;
 }
-
 function getEnvUseFrameworksLinkage(strippedLine, options) {
   const envName = strippedLine.match(
     /(?:\:linkage\s*=>|linkage:)\s*ENV\[['"]([^'"]+)['"]\](?:\.to_sym)?/,
   )?.[1];
-
   return envName ? normalizeUseFrameworksValue(options.env?.[envName]) : null;
 }
-
 function normalizeUseFrameworksValue(value) {
   if (value === 'static' || value === 'dynamic' || value === true) {
     return value;
   }
-
   return null;
 }
-
 function getPodfilePropertyName(expression) {
   return expression.match(/^podfile_properties\[['"]([^'"]+)['"]\]$/)?.[1] ?? null;
 }
-
 function getEnvName(expression) {
   return expression.match(/^ENV\[['"]([^'"]+)['"]\]$/)?.[1] ?? null;
 }
-
 function isRubyTruthy(value) {
   return value !== undefined && value !== null && value !== false;
 }
-
 function findLineEnd(content, lineStartIndex) {
   const newlineIndex = content.indexOf('\n', lineStartIndex);
   return newlineIndex === -1 ? content.length : newlineIndex + 1;
 }
-
 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 requireExpoConfigPlugins() {
   try {
     return require('expo/config-plugins');
   } catch (error) {
     try {
-      return require(require.resolve('expo/config-plugins', { paths: [process.cwd()] }));
+      const expoConfigPluginsPath = require.resolve('expo/config-plugins', {
+        paths: [process.cwd()],
+      });
+      return require(expoConfigPluginsPath);
     } catch {
       throw error;
     }
   }
 }
-
-module.exports = {
-  withNotifyKitIosNsePodfile,
-  resolveNotifyKitPackagePathFromIos,
-  normalizePodfilePath,
-  detectPodfileUseFrameworks,
-};

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

@@ -0,0 +1,155 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.ensureNotifeeExtensionFlag = ensureNotifeeExtensionFlag;
+const child_process_1 = require('child_process');
+// Keep the Expo/CLI copies identical: each is shipped through a separate build.
+// Parse, never execute, consumer Ruby. A line scanner cannot distinguish a
+// top-level assignment from continuations, interpolation, heredocs or blocks.
+const FLAG_PREFLIGHT = String.raw`
+require 'ripper'
+require 'json'
+source = STDIN.read
+ast = Ripper.sexp(source)
+def walk(node, &block)
+  return unless node.is_a?(Array)
+  yield node
+  node.each { |child| walk(child, &block) if child.is_a?(Array) }
+end
+def flag_tokens(node)
+  tokens = []
+  walk(node) { |part| tokens << part if part[0] == :@gvar && part[1] == '$NotifeeExtension' }
+  tokens
+end
+def evaluation?(node)
+  found = false
+  walk(node) do |part|
+    if [:@ident, :@const].include?(part[0]) &&
+        %w[target abstract_target pod podspec use_native_modules! use_expo_modules! use_react_native! Specification eval instance_eval class_eval module_eval from_file from_string].include?(part[1])
+      found = true
+    end
+    found = true if part[0] == :@tstring_content && part[1].include?('.podspec')
+  end
+  found
+end
+# Only a bounded prelude is provably safe before an existing true flag. Unknown
+# helpers and dynamic dispatch can evaluate podspecs even without a named call.
+def literal?(node)
+  return true if node.nil? || node == false
+  return false unless node.is_a?(Array)
+  return node.all? { |part| literal?(part) } unless node[0].is_a?(Symbol)
+  case node[0]
+  when :@int, :@float, :@rational, :@imaginary, :@tstring_content, :@label, :@ident
+    true
+  when :@kw
+    %w[true false nil].include?(node[1])
+  when :var_ref, :string_literal, :string_content, :symbol_literal, :symbol,
+       :array, :hash, :assoclist_from_args, :assoc_new, :args_add_block, :arg_paren
+    node.drop(1).all? { |part| literal?(part) }
+  else
+    false
+  end
+end
+def safe_prelude?(node)
+  return true if node[0] == :void_stmt
+  if node[0] == :assign
+    lhs = node[1]
+    return lhs && lhs[0] == :var_field &&
+      [:@ident, :@gvar, :@ivar, :@cvar, :@const].include?(lhs[1][0]) && literal?(node[2])
+  end
+  allowed = %w[require require_relative platform source project workspace install! use_frameworks!]
+  if node[0] == :command
+    return allowed.include?(node[1][1]) && literal?(node[2])
+  end
+  if node[0] == :method_add_arg && node[1][0] == :fcall
+    return allowed.include?(node[1][1][1]) && literal?(node[2])
+  end
+  false
+end
+unless ast
+  puts JSON.generate({ error: 'Ruby syntax could not be parsed', line: 1 })
+  exit
+end
+has_eval = false
+flag_text = nil
+walk(ast) do |part|
+  has_eval = true if part[0] == :@ident && %w[eval instance_eval class_eval module_eval].include?(part[1])
+  flag_text ||= part if part[0] == :@tstring_content && part[1].include?('$NotifeeExtension')
+end
+if has_eval && flag_text
+  puts JSON.generate({ error: 'dynamic Ruby evaluation mentions the flag', line: flag_text[2][0] })
+  exit
+end
+all = flag_tokens(ast)
+accepted = []
+evaluating = false
+error = nil
+(ast[1] || []).each do |statement|
+  tokens = flag_tokens(statement)
+  unless tokens.empty?
+    lhs = statement[1] if statement[0] == :assign
+    rhs = statement[2] if statement[0] == :assign
+    literal_true = lhs && lhs[0] == :var_field && lhs[1][0] == :@gvar &&
+      lhs[1][1] == '$NotifeeExtension' && rhs && rhs[0] == :var_ref && rhs[1][0] == :@kw && rhs[1][1] == 'true'
+    if !literal_true || tokens.length != 1
+      error = { error: 'conflicting or ambiguous configuration; only unconditional literal true is supported', line: tokens[0][2][0] }
+      break
+    end
+    if evaluating && accepted.empty?
+      error = { error: 'assignment follows possible target/autolinking or podspec evaluation', line: tokens[0][2][0] }
+      break
+    end
+    accepted.concat(tokens)
+  end
+  evaluating ||= evaluation?(statement) || !safe_prelude?(statement)
+end
+puts JSON.generate(error || { assigned: !accepted.empty?, references: all.length })
+`;
+function ensureNotifeeExtensionFlag(contents) {
+  if (contents.includes('$NotifeeExtension')) {
+    let result;
+    try {
+      result = JSON.parse(
+        (0, child_process_1.execFileSync)('ruby', ['-e', FLAG_PREFLIGHT], {
+          input: contents,
+          encoding: 'utf8',
+          timeout: 10_000,
+          maxBuffer: 16 * 1024 * 1024,
+        }),
+      );
+    } catch {
+      throw new Error(
+        'NotifyKit NSE: $NotifeeExtension at line 1: Ruby (Ripper) preflight unavailable. ' +
+          'Use the Ruby toolchain required by CocoaPods; no changes were written.',
+      );
+    }
+    if (result.error) {
+      throw new Error(
+        `NotifyKit NSE: $NotifeeExtension at line ${result.line}: ${result.error}. ` +
+          'Set $NotifeeExtension = true in the Podfile header before autolinking; no changes were written.',
+      );
+    }
+    if (result.assigned) return contents;
+  }
+  // Insert after Ruby's shebang, magic comments and other leading comments.
+  // Keep every original byte, including a BOM and a header without final LF.
+  const bom = contents.startsWith('\uFEFF') ? '\uFEFF' : '';
+  const text = contents.slice(bom.length);
+  const lines = text.split('\n');
+  let headerEnd = 0;
+  let blockComment = false;
+  for (let index = 0; index < lines.length; index++) {
+    const line = lines[index];
+    if (/^=begin(?:\s|$)/.test(line)) blockComment = true;
+    if (!blockComment && !/^\s*(?:#.*)?$/.test(line)) break;
+    headerEnd += line.length + (index < lines.length - 1 ? 1 : 0);
+    if (/^=end(?:\s|$)/.test(line)) blockComment = false;
+  }
+  const separator = headerEnd > 0 && text[headerEnd - 1] !== '\n' ? '\n' : '';
+  return (
+    bom +
+    text.slice(0, headerEnd) +
+    separator +
+    '$NotifeeExtension = true\n' +
+    text.slice(headerEnd)
+  );
+}