@ohos-ports/react-native-firebase-dynamic-links 0.0.0-stage → 22.4.0-beta.0

package/lib/index.js

@@ -0,0 +1,119 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  ShortLinkType: true,
+  SDK_VERSION: true,
+  firebase: true
+};
+exports.firebase = exports.default = exports.ShortLinkType = exports.SDK_VERSION = void 0;
+var _internal = require("@react-native-firebase/app/lib/internal");
+var _common = require("@react-native-firebase/app/lib/common");
+var _builder = require("./builder");
+var _version = require("./version");
+var _modular = require("./modular");
+Object.keys(_modular).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _modular[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _modular[key];
+    }
+  });
+});
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+const ShortLinkType = exports.ShortLinkType = {
+  SHORT: 'SHORT',
+  UNGUESSABLE: 'UNGUESSABLE',
+  DEFAULT: 'DEFAULT'
+};
+const statics = {
+  ShortLinkType
+};
+const namespace = 'dynamicLinks';
+const nativeModuleName = 'RNFBDynamicLinksModule';
+const nativeEvents = ['dynamic_links_link_received'];
+class FirebaseLinksModule extends _internal.FirebaseModule {
+  buildLink(dynamicLinkParams) {
+    let params;
+    try {
+      params = (0, _builder.default)(dynamicLinkParams);
+    } catch (error) {
+      throw new Error(`firebase.dynamicLinks().buildLink(*) ${error.message}`);
+    }
+    return this.native.buildLink(params);
+  }
+  buildShortLink(dynamicLinkParams, shortLinkType = 'DEFAULT') {
+    let params;
+    try {
+      params = (0, _builder.default)(dynamicLinkParams);
+    } catch (error) {
+      throw new Error(`firebase.dynamicLinks().buildShortLink(*) ${error.message}`);
+    }
+    if (shortLinkType !== 'DEFAULT' && shortLinkType !== 'SHORT' && shortLinkType !== 'UNGUESSABLE') {
+      throw new Error("firebase.dynamicLinks().buildShortLink(_, *) 'shortLinkType' expected one of DEFAULT, SHORT or UNGUESSABLE.");
+    }
+    return this.native.buildShortLink(params, shortLinkType);
+  }
+  getInitialLink() {
+    return this.native.getInitialLink();
+  }
+  onLink(listener) {
+    // TODO(salakar) rework internals as without this native module will never be ready (therefore never subscribes)
+    this.native;
+    const subscription = this.emitter.addListener('dynamic_links_link_received', event => listener(event));
+    return () => {
+      subscription.remove();
+    };
+  }
+  performDiagnostics() {
+    if (_common.isIOS) {
+      return this.native.performDiagnostics();
+    }
+    Promise.resolve();
+  }
+  resolveLink(link) {
+    if (!link) {
+      throw new Error('firebase.dynamicLinks().resolve(*) Invalid link parameter');
+    }
+    return this.native.resolveLink(link);
+  }
+}
+// import { SDK_VERSION } from '@react-native-firebase/dynamic-links';
+const SDK_VERSION = exports.SDK_VERSION = _version.default || _version;
+
+// import links from '@react-native-firebase/dynamic-links';
+// links().X(...);
+var _default = exports.default = (0, _internal.createModuleNamespace)({
+  statics,
+  version: _version.default || _version,
+  namespace,
+  nativeEvents,
+  nativeModuleName,
+  hasMultiAppSupport: false,
+  hasCustomUrlOrRegionSupport: false,
+  ModuleClass: FirebaseLinksModule
+}); // import links, { firebase } from '@react-native-firebase/dynamic-links';
+// links().X(...);
+// firebase.links().X(...);
+const firebase = exports.firebase = (0, _internal.getFirebaseRoot)();

package/lib/modular/index.d.ts

@@ -0,0 +1,148 @@
+import { ReactNativeFirebase } from '@react-native-firebase/app';
+import { FirebaseDynamicLinksTypes } from '..';
+
+type FirebaseDynamicLinks = FirebaseDynamicLinksTypes.Module;
+
+export declare const ShortLinkType = FirebaseDynamicLinksTypes.ShortLinkType;
+
+/**
+ * Returns an instance of DynamicLinks.
+ *
+ * #### Example
+ * ```js
+ * const dynamicLinks = getDynamicLinks();
+ * ```
+ */
+export declare function getDynamicLinks(
+  app?: ReactNativeFirebase.FirebaseApp,
+): FirebaseDynamicLinks;
+
+/**
+ * Builds a Dynamic Link from the provided DynamicLinkParameters instances.
+ *
+ * #### Example
+ *
+ * ```js
+ * const dynamicLinks = getDynamicLinks();
+ * const link = await buildLink(dynamicLinks, {
+ *   link: 'https://invertase.io',
+ *   domainUriPrefix: 'https://xyz.page.link',
+ *   analytics: {
+ *     campaign: 'banner',
+ *   }
+ * });
+ * ```
+ */
+export declare function buildLink(
+  dynamicLinks: FirebaseDynamicLinks,
+  dynamicLinkParams: FirebaseDynamicLinksTypes.DynamicLinkParameters,
+): Promise<string>;
+/**
+ * Builds a short Dynamic Link from the provided DynamicLinkParameters interface.
+ *
+ *  ```js
+ * const dynamicLinks = getDynamicLinks();
+ * const link = await buildShortLink(
+ *   dynamicLinks,
+ *   {
+ *     link: 'https://invertase.io',
+ *     domainUriPrefix: 'https://xyz.page.link',
+ *     analytics: {
+ *       campaign: 'banner',
+ *     }
+ *   },
+ *   ShortLinkType.UNGUESSABLE,
+ * );
+ * ```
+ */
+export declare function buildShortLink(
+  dynamicLinks: FirebaseDynamicLinks,
+  dynamicLinkParams: FirebaseDynamicLinksTypes.DynamicLinkParameters,
+  shortLinkType?: FirebaseDynamicLinksTypes.ShortLinkType,
+): Promise<string>;
+
+/**
+ * Returns the Dynamic Link that the app has been launched from. If the app was not launched from a Dynamic Link the value will be null.
+ *
+ * > Use {@link auth#isSignInWithEmailLink} to check if an inbound dynamic link is an email sign-in link.
+ *
+ * #### Example
+ *
+ * ```js
+ * async function bootstrapApp() {
+ *    const dynamicLinks = getDynamicLinks();
+ *    const initialLink = await getInitialLink(dynamicLinks);
+ *
+ *    if (initialLink) {
+ *      // Handle dynamic link inside your own application
+ *      if (initialLink.url === 'https://invertase.io/offer') return navigateTo('/offers')
+ *    }
+ * }
+ * ```
+ */
+export declare function getInitialLink(
+  dynamicLinks: FirebaseDynamicLinks,
+): Promise<FirebaseDynamicLinksTypes.DynamicLink | null>;
+
+/**
+ * Subscribe to Dynamic Link open events while the app is still running.
+ *
+ * The listener is called from Dynamic Link open events whilst the app is still running, use
+ * {@link dynamic-links#getInitialLink} for Dynamic Links which cause the app to open from a previously closed / not running state.
+ *
+ * #### Example
+ *
+ * ```jsx
+ * function App() {
+ *   const handleDynamicLink = (link) => {
+ *     // Handle dynamic link inside your own application
+ *     if (link.url === 'https://invertase.io/offer') return navigateTo('/offers')
+ *   };
+ *
+ *   useEffect(() => {
+ *     const dynamicLinks = getDynamicLinks();
+ *     const unsubscribe = onLink(dynamicLinks, handleDynamicLink);
+ *     // When the component unmounts, remove the listener
+ *     return unsubscribe;
+ *   }, []);
+ *
+ *   return <YourApp />;
+ * }
+ * ```
+ */
+export declare function onLink(
+  dynamicLinks: FirebaseDynamicLinks,
+  listener: (link: FirebaseDynamicLinksTypes.DynamicLink) => void,
+): () => void;
+
+/**
+ * Perform built-in diagnostics on iOS. This is best performed on a real device running
+ * a build from Xcode so you may see the output easily. Alternatively it should be visible
+ * in Console.app with an iPhone plugged into a macOS computer
+ *
+ * NOTE: iOS only
+ */
+export declare function performDiagnostics(dynamicLinks: FirebaseDynamicLinks): void;
+
+/**
+ * Resolve a given dynamic link (short or long) directly.
+ *
+ * This mimics the result of external link resolution, app open, and the DynamicLink you
+ * would get from {@link dynamic-links#getInitialLink}
+ *
+ * #### Example
+ *
+ * ```js
+ * const dynamicLinks = getDynamicLinks();
+ * const link = await resolveLink(dynamicLinks, 'https://reactnativefirebase.page.link/76adfasdf');
+ * console.log('Received link with URL: ' + link.url);
+ * ```
+ *
+ * Can throw error with message 'Invalid link parameter' if link parameter is null
+ * Can throw error with code 'not-found' if the link does not resolve
+ * Can throw error with code 'resolve-link-error' if there is a processing error
+ */
+export declare function resolveLink(
+  dynamicLinks: FirebaseDynamicLinks,
+  link: string,
+): Promise<FirebaseDynamicLinksTypes.DynamicLink>;

package/lib/modular/index.js

@@ -0,0 +1,110 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "ShortLinkType", {
+  enumerable: true,
+  get: function () {
+    return _.ShortLinkType;
+  }
+});
+exports.buildLink = buildLink;
+exports.buildShortLink = buildShortLink;
+exports.getDynamicLinks = getDynamicLinks;
+exports.getInitialLink = getInitialLink;
+exports.onLink = onLink;
+exports.performDiagnostics = performDiagnostics;
+exports.resolveLink = resolveLink;
+var _app = require("@react-native-firebase/app");
+var _ = require("..");
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/**
+ * @typedef {import("..").FirebaseApp} FirebaseApp
+ * @typedef {import("..").FirebaseDynamicLinksTypes.ShortLinkType} ShortLinkType
+ * @typedef {import("..").FirebaseDynamicLinksTypes.DynamicLink} DynamicLink
+ * @typedef {import("..").FirebaseDynamicLinksTypes.DynamicLinkParameters} DynamicLinkParameters
+ * @typedef {import("..").FirebaseDynamicLinksTypes.Module} FirebaseDynamicLinks
+ */
+
+// FIXME these are duplicated from the non-modular types and should be by reference
+
+/**
+ * @returns {FirebaseDynamicLinks}
+ */
+function getDynamicLinks() {
+  return (0, _app.getApp)().dynamicLinks();
+}
+
+/**
+ *
+ * @param {FirebaseDynamicLinks} dynamicLinks
+ * @param {DynamicLinkParameters} dynamicLinkParams
+ * @returns {Promise<string>}
+ */
+function buildLink(dynamicLinks, dynamicLinkParams) {
+  return dynamicLinks.buildLink(dynamicLinkParams);
+}
+
+/**
+ *
+ * @param {FirebaseDynamicLinks} dynamicLinks
+ * @param {DynamicLinkParameters} dynamicLinkParams
+ * @param {ShortLinkType | undefined} shortLinkType
+ * @returns {Promise<string>}
+ */
+function buildShortLink(dynamicLinks, dynamicLinkParams, shortLinkType) {
+  return dynamicLinks.buildShortLink(dynamicLinkParams, shortLinkType);
+}
+
+/**
+ * @param {FirebaseDynamicLinks} dynamicLinks
+ * @returns {Promise<DynamicLink | null>}
+ */
+function getInitialLink(dynamicLinks) {
+  return dynamicLinks.getInitialLink();
+}
+
+/**
+ * @param {FirebaseDynamicLinks} dynamicLinks
+ * @param {(link: DynamicLink) => void} listener
+ * @returns {() => void}
+ */
+function onLink(dynamicLinks, listener) {
+  return dynamicLinks.onLink(listener);
+}
+
+/**
+ *
+ * @param {FirebaseDynamicLinks} dynamicLinks
+ * @returns {void}
+ */
+function performDiagnostics(dynamicLinks) {
+  return dynamicLinks.performDiagnostics();
+}
+
+/**
+ *
+ * @param {FirebaseDynamicLinks} dynamicLinks
+ * @param {string} link
+ * @returns {Promise<DynamicLink>}
+ */
+function resolveLink(dynamicLinks, link) {
+  return dynamicLinks.resolveLink(link);
+}

package/lib/version.js

@@ -0,0 +1,2 @@
+// Generated by genversion.
+module.exports = '22.4.0';

package/package.json

@@ -1,6 +1,44 @@
 {
   "name": "@ohos-ports/react-native-firebase-dynamic-links",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "22.4.0-beta.0",
+  "author": "Invertase <oss@invertase.io> (http://invertase.io)",
+  "description": "React Native Firebase - Dynamic Links",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "scripts": {
+    "build": "genversion --semi lib/version.js",
+    "build:clean": "rimraf android/build && rimraf ios/build",
+    "build:plugin": "rimraf plugin/build && tsc --build plugin",
+    "lint:plugin": "eslint plugin/src/*",
+    "prepare": "yarn run build && npm run build:plugin"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ohos-ports/ohos-ports.git",
+    "directory": "ports/@react-native-firebase/dynamic-links/22.4.0"
+  },
+  "license": "Apache-2.0",
+  "keywords": [
+    "react",
+    "react-native",
+    "firebase",
+    "deep link",
+    "dynamic link"
+  ],
+  "peerDependencies": {
+    "@react-native-firebase/app": "22.4.0",
+    "@ohos-ports/expo": "^57.0.24-beta.6"
+  },
+  "devDependencies": {
+    "@ohos-ports/expo": "^57.0.24-beta.6"
+  },
+  "peerDependenciesMeta": {
+    "@ohos-ports/expo": {
+      "optional": true
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "7eaaf185aab15c7e4fc3c218af9be609fe7e0030"
+}

package/plugin/build/index.d.ts

@@ -0,0 +1,3 @@
+import { ConfigPlugin } from '@expo/config-plugins';
+declare const _default: ConfigPlugin<void>;
+export default _default;

package/plugin/build/index.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+const config_plugins_1 = require("@expo/config-plugins");
+const ios_1 = require("./ios");
+/**
+ * A config plugin for configuring `@react-native-firebase/dynamic-links`
+ */
+const withRnFirebaseDynamicLinks = config => {
+  return (0, config_plugins_1.withPlugins)(config, [
+  // iOS
+  ios_1.withFirebaseAppDelegate]);
+};
+const pak = require('@react-native-firebase/dynamic-links/package.json');
+exports.default = (0, config_plugins_1.createRunOncePlugin)(withRnFirebaseDynamicLinks, pak.name, pak.version);

package/plugin/build/ios/appDelegate.d.ts

@@ -0,0 +1,5 @@
+import { ConfigPlugin } from '@expo/config-plugins';
+import { AppDelegateProjectFile } from '@expo/config-plugins/build/ios/Paths';
+export declare function modifyObjcAppDelegate(contents: string): string;
+export declare function modifyAppDelegateAsync(appDelegateFileInfo: AppDelegateProjectFile): Promise<void>;
+export declare const withFirebaseAppDelegate: ConfigPlugin;

package/plugin/build/ios/appDelegate.js

@@ -0,0 +1,86 @@
+"use strict";
+
+var __importDefault = void 0 && (void 0).__importDefault || function (mod) {
+  return mod && mod.__esModule ? mod : {
+    "default": mod
+  };
+};
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.withFirebaseAppDelegate = void 0;
+exports.modifyObjcAppDelegate = modifyObjcAppDelegate;
+exports.modifyAppDelegateAsync = modifyAppDelegateAsync;
+const config_plugins_1 = require("@expo/config-plugins");
+const generateCode_1 = require("@expo/config-plugins/build/utils/generateCode");
+const fs_1 = __importDefault(require("fs"));
+const methodInvocationBlock = `[RNFBDynamicLinksAppDelegateInterceptor sharedInstance];`;
+// https://regex101.com/r/mPgaq6/1
+const methodInvocationLineMatcher = /(?:self\.moduleName\s*=\s*@\"([^"]*)\";)|(?:(self\.|_)(\w+)\s?=\s?\[\[UMModuleRegistryAdapter alloc\])|(?:RCTBridge\s?\*\s?(\w+)\s?=\s?\[(\[RCTBridge alloc\]|self\.reactDelegate))/g;
+// https://regex101.com/r/nHrTa9/1/
+// if the above regex fails, we can use this one as a fallback:
+const fallbackInvocationLineMatcher = /-\s*\(BOOL\)\s*application:\s*\(UIApplication\s*\*\s*\)\s*\w+\s+didFinishLaunchingWithOptions:/g;
+function modifyObjcAppDelegate(contents) {
+  // Add import
+  if (!contents.includes('#import <RNFBDynamicLinksAppDelegateInterceptor.h>')) {
+    contents = contents.replace(/#import "AppDelegate.h"/g, `#import "AppDelegate.h"
+#import <RNFBDynamicLinksAppDelegateInterceptor.h>`);
+  }
+  // To avoid potential issues with existing changes from older plugin versions
+  if (contents.includes(methodInvocationBlock)) {
+    return contents;
+  }
+  if (!methodInvocationLineMatcher.test(contents) && !fallbackInvocationLineMatcher.test(contents)) {
+    config_plugins_1.WarningAggregator.addWarningIOS('@react-native-firebase/dynamic-links', 'Unable to determine correct Firebase insertion point in AppDelegate.m. Skipping Firebase addition.');
+    return contents;
+  }
+  // Add invocation
+  try {
+    return (0, generateCode_1.mergeContents)({
+      tag: '@react-native-firebase/dynamic-links-didFinishLaunchingWithOptions',
+      src: contents,
+      newSrc: methodInvocationBlock,
+      anchor: methodInvocationLineMatcher,
+      offset: 0,
+      // new line will be inserted right above matched anchor
+      comment: '//'
+    }).contents;
+  } catch (_) {
+    // tests if the opening `{` is in the new line
+    const multilineMatcher = new RegExp(fallbackInvocationLineMatcher.source + '.+\\n*{');
+    const isHeaderMultiline = multilineMatcher.test(contents);
+    // we fallback to another regex if the first one fails
+    return (0, generateCode_1.mergeContents)({
+      tag: '@react-native-firebase/app-didFinishLaunchingWithOptions-fallback',
+      src: contents,
+      newSrc: methodInvocationBlock,
+      anchor: fallbackInvocationLineMatcher,
+      // new line will be inserted right below matched anchor
+      // or two lines, if the `{` is in the new line
+      offset: isHeaderMultiline ? 2 : 1,
+      comment: '//'
+    }).contents;
+  }
+}
+async function modifyAppDelegateAsync(appDelegateFileInfo) {
+  const {
+    language,
+    path,
+    contents
+  } = appDelegateFileInfo;
+  if (['objc', 'objcpp'].includes(language)) {
+    const newContents = modifyObjcAppDelegate(contents);
+    await fs_1.default.promises.writeFile(path, newContents);
+  } else {
+    // TODO: Support Swift
+    throw new Error(`Cannot add Firebase code to AppDelegate of language "${language}"`);
+  }
+}
+const withFirebaseAppDelegate = config => {
+  return (0, config_plugins_1.withDangerousMod)(config, ['ios', async config => {
+    const fileInfo = config_plugins_1.IOSConfig.Paths.getAppDelegate(config.modRequest.projectRoot);
+    await modifyAppDelegateAsync(fileInfo);
+    return config;
+  }]);
+};
+exports.withFirebaseAppDelegate = withFirebaseAppDelegate;

package/plugin/build/ios/index.d.ts

@@ -0,0 +1,2 @@
+import { withFirebaseAppDelegate } from './appDelegate';
+export { withFirebaseAppDelegate };

package/plugin/build/ios/index.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.withFirebaseAppDelegate = void 0;
+const appDelegate_1 = require("./appDelegate");
+Object.defineProperty(exports, "withFirebaseAppDelegate", {
+  enumerable: true,
+  get: function () {
+    return appDelegate_1.withFirebaseAppDelegate;
+  }
+});

package/plugin/src/index.ts

@@ -0,0 +1,15 @@
+import { ConfigPlugin, withPlugins, createRunOncePlugin } from '@expo/config-plugins';
+import { withFirebaseAppDelegate } from './ios';
+
+/**
+ * A config plugin for configuring `@react-native-firebase/dynamic-links`
+ */
+const withRnFirebaseDynamicLinks: ConfigPlugin = config => {
+  return withPlugins(config, [
+    // iOS
+    withFirebaseAppDelegate,
+  ]);
+};
+
+const pak = require('@react-native-firebase/dynamic-links/package.json');
+export default createRunOncePlugin(withRnFirebaseDynamicLinks, pak.name, pak.version);

package/plugin/src/ios/appDelegate.ts

@@ -0,0 +1,92 @@
+import { ConfigPlugin, IOSConfig, WarningAggregator, withDangerousMod } from '@expo/config-plugins';
+import { AppDelegateProjectFile } from '@expo/config-plugins/build/ios/Paths';
+import { mergeContents } from '@expo/config-plugins/build/utils/generateCode';
+import fs from 'fs';
+
+const methodInvocationBlock = `[RNFBDynamicLinksAppDelegateInterceptor sharedInstance];`;
+// https://regex101.com/r/mPgaq6/1
+const methodInvocationLineMatcher =
+  /(?:self\.moduleName\s*=\s*@\"([^"]*)\";)|(?:(self\.|_)(\w+)\s?=\s?\[\[UMModuleRegistryAdapter alloc\])|(?:RCTBridge\s?\*\s?(\w+)\s?=\s?\[(\[RCTBridge alloc\]|self\.reactDelegate))/g;
+
+// https://regex101.com/r/nHrTa9/1/
+// if the above regex fails, we can use this one as a fallback:
+const fallbackInvocationLineMatcher =
+  /-\s*\(BOOL\)\s*application:\s*\(UIApplication\s*\*\s*\)\s*\w+\s+didFinishLaunchingWithOptions:/g;
+
+export function modifyObjcAppDelegate(contents: string): string {
+  // Add import
+  if (!contents.includes('#import <RNFBDynamicLinksAppDelegateInterceptor.h>')) {
+    contents = contents.replace(
+      /#import "AppDelegate.h"/g,
+      `#import "AppDelegate.h"
+#import <RNFBDynamicLinksAppDelegateInterceptor.h>`,
+    );
+  }
+
+  // To avoid potential issues with existing changes from older plugin versions
+  if (contents.includes(methodInvocationBlock)) {
+    return contents;
+  }
+
+  if (
+    !methodInvocationLineMatcher.test(contents) &&
+    !fallbackInvocationLineMatcher.test(contents)
+  ) {
+    WarningAggregator.addWarningIOS(
+      '@react-native-firebase/dynamic-links',
+      'Unable to determine correct Firebase insertion point in AppDelegate.m. Skipping Firebase addition.',
+    );
+    return contents;
+  }
+
+  // Add invocation
+  try {
+    return mergeContents({
+      tag: '@react-native-firebase/dynamic-links-didFinishLaunchingWithOptions',
+      src: contents,
+      newSrc: methodInvocationBlock,
+      anchor: methodInvocationLineMatcher,
+      offset: 0, // new line will be inserted right above matched anchor
+      comment: '//',
+    }).contents;
+  } catch (_: any) {
+    // tests if the opening `{` is in the new line
+    const multilineMatcher = new RegExp(fallbackInvocationLineMatcher.source + '.+\\n*{');
+    const isHeaderMultiline = multilineMatcher.test(contents);
+
+    // we fallback to another regex if the first one fails
+    return mergeContents({
+      tag: '@react-native-firebase/app-didFinishLaunchingWithOptions-fallback',
+      src: contents,
+      newSrc: methodInvocationBlock,
+      anchor: fallbackInvocationLineMatcher,
+      // new line will be inserted right below matched anchor
+      // or two lines, if the `{` is in the new line
+      offset: isHeaderMultiline ? 2 : 1,
+      comment: '//',
+    }).contents;
+  }
+}
+
+export async function modifyAppDelegateAsync(appDelegateFileInfo: AppDelegateProjectFile) {
+  const { language, path, contents } = appDelegateFileInfo;
+
+  if (['objc', 'objcpp'].includes(language)) {
+    const newContents = modifyObjcAppDelegate(contents);
+    await fs.promises.writeFile(path, newContents);
+  } else {
+    // TODO: Support Swift
+    throw new Error(`Cannot add Firebase code to AppDelegate of language "${language}"`);
+  }
+}
+
+export const withFirebaseAppDelegate: ConfigPlugin = config => {
+  return withDangerousMod(config, [
+    'ios',
+    async config => {
+      const fileInfo = IOSConfig.Paths.getAppDelegate(config.modRequest.projectRoot);
+      await modifyAppDelegateAsync(fileInfo);
+      return config;
+    },
+  ]);
+};

package/plugin/src/ios/index.ts

@@ -0,0 +1,3 @@
+import { withFirebaseAppDelegate } from './appDelegate';
+
+export { withFirebaseAppDelegate };