@advenue/react-native 0.3.0

package/plugin/links.js

@@ -0,0 +1,79 @@
+// @ts-check
+// Pure config transforms for the Advenue Expo config plugin. Kept free of any
+// @expo/config-plugins import so they are unit-testable with plain objects.
+
+const ASSOC_KEY = 'com.apple.developer.associated-domains';
+
+/**
+ * Returns a copy of the iOS entitlements with `applinks:<domain>` added for each
+ * domain (deduped, existing entries preserved). Enables iOS Universal Links.
+ */
+function addAssociatedDomains(entitlements, domains) {
+  const existing = Array.isArray(entitlements[ASSOC_KEY]) ? entitlements[ASSOC_KEY] : [];
+  const next = [...existing];
+  for (const domain of domains) {
+    const entry = `applinks:${domain}`;
+    if (!next.includes(entry)) {
+      next.push(entry);
+    }
+  }
+  return { ...entitlements, [ASSOC_KEY]: next };
+}
+
+function attr(name) {
+  return { $: { 'android:name': name } };
+}
+
+function findMainActivity(manifest) {
+  const application = manifest?.manifest?.application?.[0];
+  const activities = application?.activity ?? [];
+  return (
+    activities.find((activity) =>
+      (activity['intent-filter'] ?? []).some(
+        (filter) =>
+          (filter.action ?? []).some(
+            (a) => a.$?.['android:name'] === 'android.intent.action.MAIN',
+          ) &&
+          (filter.category ?? []).some(
+            (c) => c.$?.['android:name'] === 'android.intent.category.LAUNCHER',
+          ),
+      ),
+    ) ?? activities[0]
+  );
+}
+
+/**
+ * Appends an autoVerify App Links intent filter (https + each host) to the main
+ * activity, enabling Android App Links. Mutates and returns the manifest.
+ * Idempotent: a filter already covering a host is not duplicated. No-op when
+ * `domains` is empty or no activity exists.
+ */
+function addAppLinksIntentFilter(manifest, domains) {
+  if (!domains || domains.length === 0) {
+    return manifest;
+  }
+  const activity = findMainActivity(manifest);
+  if (!activity) {
+    return manifest;
+  }
+  activity['intent-filter'] ??= [];
+  const filters = activity['intent-filter'];
+
+  const alreadyCovered = (host) =>
+    filters.some((filter) => (filter.data ?? []).some((d) => d.$?.['android:host'] === host));
+  const fresh = domains.filter((host) => !alreadyCovered(host));
+  if (fresh.length === 0) {
+    return manifest;
+  }
+
+  filters.push({
+    $: { 'android:autoVerify': 'true' },
+    action: [attr('android.intent.action.VIEW')],
+    category: [attr('android.intent.category.DEFAULT'), attr('android.intent.category.BROWSABLE')],
+    data: fresh.map((host) => ({ $: { 'android:scheme': 'https', 'android:host': host } })),
+  });
+
+  return manifest;
+}
+
+module.exports = { addAssociatedDomains, addAppLinksIntentFilter, ASSOC_KEY };

package/plugin/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/src/deep-links.ts

@@ -0,0 +1,85 @@
+import type { DeepLink } from '@advenue/sdk-core';
+
+/** Handle for tearing down the OS deep-link listener. */
+export interface DeepLinkSubscription {
+  remove(): void;
+}
+
+/** Subscription plus a `ready` promise that settles once cold-start resolution finishes. */
+export interface DeepLinkHandle extends DeepLinkSubscription {
+  /** Resolves after the cold-start link (direct or deferred) has been delivered. */
+  ready: Promise<void>;
+}
+
+/**
+ * Parses an OS-delivered link (Universal Link, App Link, or custom scheme) into
+ * the unified {@link DeepLink} shape. The `deepLinkValue` is a best-effort path
+ * (host + path for custom schemes, path for http(s)); the raw `url` is always
+ * provided so the host app can parse it itself when needed.
+ */
+export function parseDirectLink(url: string): DeepLink {
+  let deepLinkValue = '';
+  let params: Record<string, string> | undefined;
+
+  try {
+    const parsed = new URL(url);
+    const path = parsed.pathname.replace(/^\/+/, '');
+    // Custom schemes (myapp://product/1) put the first segment in the host.
+    const isHttp = parsed.protocol === 'http:' || parsed.protocol === 'https:';
+    deepLinkValue = isHttp ? path : [parsed.host, path].filter(Boolean).join('/');
+
+    for (const [k, v] of parsed.searchParams.entries()) {
+      params ??= {};
+      params[k] = v;
+    }
+  } catch {
+    // Unparseable URL — surface the raw value so the app can still route.
+    deepLinkValue = url;
+  }
+
+  return {
+    deepLinkValue,
+    ...(params ? { params } : {}),
+    url,
+    isDeferred: false,
+    isFirstLaunch: false,
+  };
+}
+
+export interface DeepLinkSetup {
+  /** OS cold-start URL (RN Linking.getInitialURL). */
+  getInitialURL: () => Promise<string | null>;
+  /** Subscribes to warm OS links (RN Linking 'url' event). */
+  addUrlListener: (handler: (url: string) => void) => DeepLinkSubscription;
+  /** Resolves the deferred deep link (client.resolveDeferredDeepLink). */
+  resolveDeferred: () => Promise<DeepLink | null>;
+  /** Fired for every resolved deep link (direct or deferred). The app navigates. */
+  onDeepLink: (link: DeepLink) => void;
+}
+
+/**
+ * Unifies direct and deferred deep links behind a single callback (AppsFlyer UDL
+ * style). The OS-link listener is registered synchronously and the handle is
+ * returned immediately so app init never blocks on the deferred poll (which can
+ * back off for seconds). Cold-start resolution runs in the background: a direct
+ * OS link wins and deferred resolution is skipped (the user arrived via a real
+ * link); otherwise the deferred poll runs and fires only when it yields a
+ * `deepLinkValue`. Await `handle.ready` to observe completion (used in tests).
+ */
+export function setupDeepLinks(setup: DeepLinkSetup): DeepLinkHandle {
+  const listener = setup.addUrlListener((url) => setup.onDeepLink(parseDirectLink(url)));
+
+  const ready = (async () => {
+    const initial = await setup.getInitialURL();
+    if (initial) {
+      setup.onDeepLink(parseDirectLink(initial));
+      return;
+    }
+    const deferred = await setup.resolveDeferred();
+    if (deferred?.deepLinkValue) {
+      setup.onDeepLink(deferred);
+    }
+  })();
+
+  return { remove: () => listener.remove(), ready };
+}