@dl2app/react-native 0.0.0-stage → 0.1.1

package/build/src/index.d.ts

@@ -0,0 +1,22 @@
+declare const DL2: {
+    configure: (config: import("./types").DL2Config) => void;
+    onLink: (listener: (event: import("./types").DL2LinkEvent) => void) => () => void;
+    getInitialLink: () => Promise<import("./types").DL2LinkEvent | null>;
+    resolve: (url: string) => Promise<import("./types").DL2LinkEvent | null>;
+    track: (name: string, options?: import("./types").DL2TrackOptions) => void;
+    flush: () => Promise<void | undefined>;
+    createLink: (input: import("./types").DL2CreateLinkInput) => Promise<{
+        url: string;
+    } | null>;
+    matchClipboard: (text: string) => Promise<import("./types").DL2LinkEvent | null>;
+    reset: () => Promise<void>;
+    getInstallId: () => Promise<string | null>;
+    getDebugInfo: () => import("./types").DL2DebugInfo;
+    version: string;
+};
+export default DL2;
+export { DL2 };
+export { DL2PasteButton } from "./PasteButton";
+export type { DL2PasteButtonProps } from "./PasteButton";
+export { parseUrl, extractClipboardToken, SDK_VERSION } from "./core";
+export type { DL2Config, DL2CreateLinkInput, DL2DebugInfo, DL2Error, DL2ErrorCode, DL2LinkEvent, DL2LinkSource, DL2MatchMethod, DL2TrackOptions, } from "./types";

package/build/src/index.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SDK_VERSION = exports.extractClipboardToken = exports.parseUrl = exports.DL2PasteButton = exports.DL2 = void 0;
+const react_native_1 = require("react-native");
+const expo_modules_core_1 = require("expo-modules-core");
+const core_1 = require("./core");
+function loadNative() {
+    try {
+        return (0, expo_modules_core_1.requireOptionalNativeModule)("DL2");
+    }
+    catch {
+        return null;
+    }
+}
+const DL2 = (0, core_1.createDL2)({
+    native: loadNative(),
+    linking: react_native_1.Linking,
+    platform: react_native_1.Platform.OS,
+    screen: () => {
+        // Points (iOS) and dp (Android): the same unit as `screen.width` in the browser that clicked.
+        const s = react_native_1.Dimensions.get("screen");
+        return { w: Math.round(s.width), h: Math.round(s.height), dpr: react_native_1.PixelRatio.get() };
+    },
+    fetch: (url, init) => fetch(url, init),
+});
+exports.DL2 = DL2;
+exports.default = DL2;
+var PasteButton_1 = require("./PasteButton");
+Object.defineProperty(exports, "DL2PasteButton", { enumerable: true, get: function () { return PasteButton_1.DL2PasteButton; } });
+var core_2 = require("./core");
+Object.defineProperty(exports, "parseUrl", { enumerable: true, get: function () { return core_2.parseUrl; } });
+Object.defineProperty(exports, "extractClipboardToken", { enumerable: true, get: function () { return core_2.extractClipboardToken; } });
+Object.defineProperty(exports, "SDK_VERSION", { enumerable: true, get: function () { return core_2.SDK_VERSION; } });

package/build/src/types.d.ts

@@ -0,0 +1,130 @@
+export type DL2ErrorCode = "not_configured" | "network" | "timeout" | "invalid_key" | "app_mismatch" | "link_not_found" | "rate_limited" | "unknown";
+export type DL2Error = {
+    code: DL2ErrorCode;
+    message: string;
+    cause?: unknown;
+    /** HTTP status when the error came from an API response. */
+    status?: number;
+};
+export type DL2LinkSource = "universal_link" | "app_link" | "uri_scheme" | "deferred";
+export type DL2MatchMethod = "install_referrer" | "fingerprint" | "clipboard";
+export type DL2LinkEvent = {
+    /** The URL that opened the app, or the short link that was matched. */
+    url: string | null;
+    /** Path to navigate to, for example "/invite/42". */
+    path: string;
+    /** Query parameters of the link. */
+    params: Record<string, string>;
+    /** The link's deep link data. */
+    data: Record<string, unknown>;
+    source: DL2LinkSource;
+    isFirstOpen: boolean;
+    matchMethod?: DL2MatchMethod;
+    confidence?: number;
+    linkId?: string;
+    utm?: Record<string, string>;
+};
+export type DL2Config = {
+    publishableKey: string;
+    /** Every host your links use: the default host, the "-alt" host and custom domains. */
+    linkDomains: string[];
+    /** Optional custom URL scheme, without "://". */
+    uriScheme?: string;
+    /** Defaults: enabled true, timeoutMs 4000, useClipboard false. */
+    deferred?: {
+        enabled?: boolean;
+        timeoutMs?: number;
+        useClipboard?: boolean;
+    };
+    /** Default https://api.dl2.app */
+    apiBaseUrl?: string;
+    debug?: boolean;
+    onError?: (e: DL2Error) => void;
+};
+export type DL2TrackOptions = {
+    value?: number;
+    /** ISO 4217 code, for example "USD". */
+    currency?: string;
+    props?: Record<string, unknown>;
+};
+export type DL2CreateLinkInput = {
+    path: string;
+    data?: Record<string, unknown>;
+    og?: {
+        title?: string;
+        description?: string;
+        image?: string;
+    };
+    utm?: Record<string, string>;
+};
+export type DL2DebugInfo = {
+    sdkVersion: string;
+    configured: boolean;
+    nativeModule: boolean;
+    installId: string | null;
+    isFirstLaunch: boolean;
+    queuedEvents: number;
+    lastOpenResponse: unknown;
+    lastResolveResponse: unknown;
+    lastError: DL2Error | null;
+};
+export type DL2DeviceInfo = {
+    osVersion?: string;
+    appId?: string;
+    appVersion?: string;
+    lang?: string;
+    tz?: string;
+};
+/** The native module (Expo Modules API). Every function is asynchronous. */
+export interface DL2Native {
+    getItem(key: string): Promise<string | null>;
+    setItem(key: string, value: string): Promise<void>;
+    removeItem(key: string): Promise<void>;
+    /** Android: Play Install Referrer string. iOS: always null. */
+    getInstallReferrer(): Promise<string | null>;
+    getDeviceInfo(): Promise<DL2DeviceInfo>;
+    /**
+     * When the app was installed, in ms since epoch, or null when unknown. Android: the package's
+     * firstInstallTime. iOS: the creation date of the app's data container.
+     */
+    getInstalledAt?(): Promise<number | null>;
+    /**
+     * Android: true when the activity was reopened from Recents, so its intent (and the URL in it)
+     * is the one from the original launch. iOS does not have it.
+     */
+    isLaunchedFromHistory?(): Promise<boolean>;
+    uuid?(): Promise<string>;
+}
+export type DL2FetchResponse = {
+    ok: boolean;
+    status: number;
+    json(): Promise<unknown>;
+};
+/** Everything the core needs from the platform. Injected so the core runs in plain Node for tests. */
+export interface DL2Deps {
+    /** null when the native module is not linked (for example in Expo Go). */
+    native: DL2Native | null;
+    linking: {
+        getInitialURL(): Promise<string | null>;
+        addEventListener(type: "url", handler: (e: {
+            url: string;
+        }) => void): {
+            remove(): void;
+        } | void;
+    };
+    platform: string;
+    screen(): {
+        w: number;
+        h: number;
+        dpr: number;
+    };
+    fetch(url: string, init: {
+        method: string;
+        headers: Record<string, string>;
+        body: string;
+        signal?: unknown;
+    }): Promise<DL2FetchResponse>;
+    sleep?(ms: number): Promise<void>;
+    now?(): number;
+    random?(): number;
+}

package/build/src/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/expo-module.config.json

@@ -0,0 +1,5 @@
+{
+  "platforms": ["ios", "android"],
+  "ios": { "modules": ["DL2Module"] },
+  "android": { "modules": ["app.dl2.reactnative.DL2Module"] }
+}

package/ios/DL2Module.swift

@@ -0,0 +1,59 @@
+import ExpoModulesCore
+import UIKit
+
+// Key-value storage, device info, the install time and the system paste button. Nothing else.
+// The clipboard is never read here: text only arrives when the user taps DL2PasteButtonView.
+public class DL2Module: Module {
+  private var store: UserDefaults {
+    return UserDefaults(suiteName: "app.dl2.sdk") ?? UserDefaults.standard
+  }
+
+  public func definition() -> ModuleDefinition {
+    Name("DL2")
+
+    AsyncFunction("getItem") { (key: String) -> String? in
+      return self.store.string(forKey: key)
+    }
+
+    AsyncFunction("setItem") { (key: String, value: String) in
+      self.store.set(value, forKey: key)
+    }
+
+    AsyncFunction("removeItem") { (key: String) in
+      self.store.removeObject(forKey: key)
+    }
+
+    // The install referrer is an Android (Google Play) concept.
+    AsyncFunction("getInstallReferrer") { () -> String? in
+      return nil
+    }
+
+    AsyncFunction("uuid") { () -> String in
+      return UUID().uuidString.lowercased()
+    }
+
+    AsyncFunction("getDeviceInfo") { () -> [String: String] in
+      let bundle = Bundle.main
+      return [
+        "osVersion": UIDevice.current.systemVersion,
+        "appId": bundle.bundleIdentifier ?? "",
+        "appVersion": (bundle.infoDictionary?["CFBundleShortVersionString"] as? String) ?? "",
+        "lang": Locale.preferredLanguages.first ?? "",
+        "tz": TimeZone.current.identifier
+      ]
+    }
+
+    // When the app was installed, in ms since epoch. iOS has no API for it; the data
+    // container's Library directory is created with the install. Nil when it cannot be read.
+    AsyncFunction("getInstalledAt") { () -> Double? in
+      guard let dir = FileManager.default.urls(for: .libraryDirectory, in: .userDomainMask).first,
+            let created = (try? FileManager.default.attributesOfItem(atPath: dir.path))?[.creationDate] as? Date
+      else { return nil }
+      return (created.timeIntervalSince1970 * 1000).rounded()
+    }
+
+    View(DL2PasteButtonView.self) {
+      Events("onPaste")
+    }
+  }
+}

package/ios/DL2PasteButtonView.swift

@@ -0,0 +1,41 @@
+import ExpoModulesCore
+import UIKit
+
+// Hosts the system paste button (UIPasteControl, iOS 16+). iOS gives the app the clipboard
+// content only after the user taps it, without the "pasted from" banner or a permission alert.
+// On older iOS the view stays empty.
+final class DL2PasteButtonView: ExpoView {
+  let onPaste = EventDispatcher()
+  private var control: UIView?
+
+  required init(appContext: AppContext? = nil) {
+    super.init(appContext: appContext)
+    pasteConfiguration = UIPasteConfiguration(acceptableTypeIdentifiers: ["public.plain-text", "public.url"])
+    if #available(iOS 16.0, *) {
+      let configuration = UIPasteControl.Configuration()
+      configuration.displayMode = .iconAndLabel
+      configuration.cornerStyle = .capsule
+      let paste = UIPasteControl(configuration: configuration)
+      paste.target = self
+      addSubview(paste)
+      control = paste
+    }
+  }
+
+  override func layoutSubviews() {
+    super.layoutSubviews()
+    control?.frame = bounds
+  }
+
+  override func paste(itemProviders: [NSItemProvider]) {
+    guard let provider = itemProviders.first(where: { $0.canLoadObject(ofClass: NSString.self) }) else {
+      return
+    }
+    _ = provider.loadObject(ofClass: NSString.self) { [weak self] value, _ in
+      guard let text = value as? String else { return }
+      DispatchQueue.main.async {
+        self?.onPaste(["text": text])
+      }
+    }
+  }
+}

package/ios/DL2ReactNative.podspec

@@ -0,0 +1,22 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, '..', 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name           = 'DL2ReactNative'
+  s.version        = package['version']
+  s.summary        = package['description']
+  s.description    = package['description']
+  s.license        = package['license']
+  s.author         = 'DL2'
+  s.homepage       = 'https://dl2.app'
+  s.platforms      = { :ios => '13.4' }
+  s.swift_version  = '5.4'
+  s.source         = { :git => 'https://github.com/dl2app/dl2-react-native.git', :tag => "v#{s.version}" }
+  s.static_framework = true
+
+  s.dependency 'ExpoModulesCore'
+
+  s.source_files = '*.swift'
+  s.resource_bundles = { 'DL2ReactNative_Privacy' => ['PrivacyInfo.xcprivacy'] }
+end

package/ios/PrivacyInfo.xcprivacy

@@ -0,0 +1,76 @@
+<?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>
+	<!-- The SDK does not track: no IDFA, no cross-app or cross-site identifiers. -->
+	<key>NSPrivacyTracking</key>
+	<false/>
+	<key>NSPrivacyTrackingDomains</key>
+	<array/>
+	<key>NSPrivacyCollectedDataTypes</key>
+	<array>
+		<!-- install_id: a random ID created by the SDK for this install. -->
+		<dict>
+			<key>NSPrivacyCollectedDataType</key>
+			<string>NSPrivacyCollectedDataTypeDeviceID</string>
+			<key>NSPrivacyCollectedDataTypeLinked</key>
+			<false/>
+			<key>NSPrivacyCollectedDataTypeTracking</key>
+			<false/>
+			<key>NSPrivacyCollectedDataTypePurposes</key>
+			<array>
+				<string>NSPrivacyCollectedDataTypePurposeAppFunctionality</string>
+				<string>NSPrivacyCollectedDataTypePurposeAnalytics</string>
+			</array>
+		</dict>
+		<!-- Link opens and events sent with DL2.track(). -->
+		<dict>
+			<key>NSPrivacyCollectedDataType</key>
+			<string>NSPrivacyCollectedDataTypeProductInteraction</string>
+			<key>NSPrivacyCollectedDataTypeLinked</key>
+			<false/>
+			<key>NSPrivacyCollectedDataTypeTracking</key>
+			<false/>
+			<key>NSPrivacyCollectedDataTypePurposes</key>
+			<array>
+				<string>NSPrivacyCollectedDataTypePurposeAppFunctionality</string>
+				<string>NSPrivacyCollectedDataTypePurposeAnalytics</string>
+			</array>
+		</dict>
+		<!-- OS version, screen size, language and time zone, used once to match a deferred link. -->
+		<dict>
+			<key>NSPrivacyCollectedDataType</key>
+			<string>NSPrivacyCollectedDataTypeOtherDiagnosticData</string>
+			<key>NSPrivacyCollectedDataTypeLinked</key>
+			<false/>
+			<key>NSPrivacyCollectedDataTypeTracking</key>
+			<false/>
+			<key>NSPrivacyCollectedDataTypePurposes</key>
+			<array>
+				<string>NSPrivacyCollectedDataTypePurposeAppFunctionality</string>
+			</array>
+		</dict>
+	</array>
+	<key>NSPrivacyAccessedAPITypes</key>
+	<array>
+		<!-- UserDefaults: the SDK stores its own install_id and event queue. -->
+		<dict>
+			<key>NSPrivacyAccessedAPIType</key>
+			<string>NSPrivacyAccessedAPICategoryUserDefaults</string>
+			<key>NSPrivacyAccessedAPITypeReasons</key>
+			<array>
+				<string>CA92.1</string>
+			</array>
+		</dict>
+		<!-- File timestamp: the creation date of the app's own Library directory, read as the install time. -->
+		<dict>
+			<key>NSPrivacyAccessedAPIType</key>
+			<string>NSPrivacyAccessedAPICategoryFileTimestamp</string>
+			<key>NSPrivacyAccessedAPITypeReasons</key>
+			<array>
+				<string>C617.1</string>
+			</array>
+		</dict>
+	</array>
+</dict>
+</plist>

package/package.json

@@ -1,6 +1,37 @@
 {
   "name": "@dl2app/react-native",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "DL2App deep links for React Native and Expo: universal links, app links, deferred deep links and events.",
+  "license": "MIT",
+  "homepage": "https://dl2.app/docs",
+  "main": "build/src/index.js",
+  "types": "build/src/index.d.ts",
+  "react-native": "src/index.ts",
+  "sideEffects": false,
+  "files": [
+    "src",
+    "build",
+    "plugin/src",
+    "app.plugin.js",
+    "expo-module.config.json",
+    "ios",
+    "android/build.gradle",
+    "android/src",
+    "README.md"
+  ],
+  "scripts": {
+    "typecheck": "tsc -p . --noEmit",
+    "build": "tsc -p tsconfig.build.json",
+    "prepare": "npm run build"
+  },
+  "keywords": ["react-native", "expo", "deep-linking", "universal-links", "app-links", "deferred-deep-link"],
+  "peerDependencies": {
+    "expo": ">=51.0.0",
+    "expo-modules-core": "*",
+    "react": "*",
+    "react-native": ">=0.74.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.3"
+  }
+}

package/plugin/src/withDL2.ts

@@ -0,0 +1,202 @@
+/**
+ * Expo config plugin for @dl2app/react-native.
+ *
+ * It only edits the Expo config object (`ios.associatedDomains`, `android.intentFilters`,
+ * `scheme`); Expo's own prebuild steps turn those into entitlements and manifest entries.
+ * That keeps it a pure function: same input, same output, safe to run any number of times.
+ */
+
+export type DL2PluginOptions = {
+  /** Your DL2 project subdomain. Adds `{subdomain}.dl2.app` and `{subdomain}-alt.dl2.app`. */
+  subdomain?: string;
+  /** Only for self-hosted DL2. Default "dl2.app". */
+  rootDomain?: string;
+  /** Extra hosts (custom domains), or the full list if you do not pass `subdomain`. */
+  domains?: string[];
+  /** Adds `?mode=developer` to the iOS entries so iOS fetches the AASA file directly. Default false. */
+  iosDeveloperMode?: boolean;
+  /** Adds `android:autoVerify="true"` to the intent filter. Default true. */
+  androidAutoVerify?: boolean;
+  /** Optional custom URL scheme, without "://". */
+  uriScheme?: string;
+};
+
+export type NormalizedOptions = {
+  domains: string[];
+  iosDeveloperMode: boolean;
+  androidAutoVerify: boolean;
+  uriScheme: string | null;
+};
+
+type IntentFilterData = { scheme?: string; host?: string; [k: string]: unknown };
+type IntentFilter = {
+  action?: string;
+  autoVerify?: boolean;
+  data?: IntentFilterData | IntentFilterData[];
+  category?: string | string[];
+  [k: string]: unknown;
+};
+
+export type ExpoConfigLike = {
+  scheme?: string | string[];
+  ios?: { associatedDomains?: string[]; [k: string]: unknown };
+  android?: { intentFilters?: IntentFilter[]; [k: string]: unknown };
+  [k: string]: unknown;
+};
+
+const NAME = "@dl2app/react-native";
+const ALLOWED = ["subdomain", "rootDomain", "domains", "iosDeveloperMode", "androidAutoVerify", "uriScheme"];
+const HOST = /^(\*\.)?([a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z]{2,63}$/;
+const LABEL = /^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?$/;
+const SCHEME = /^[a-z][a-z0-9+.-]*$/;
+
+function fail(message: string): never {
+  throw new Error(`[${NAME}] ${message}`);
+}
+
+function checkHost(value: unknown, where: string): string {
+  if (typeof value !== "string" || !value.trim()) fail(`${where} must be a host name such as "myapp.dl2.app".`);
+  const host = (value as string).trim().toLowerCase();
+  if (/^[a-z][a-z0-9+.-]*:\/\//.test(host)) fail(`${where} is "${value}". Remove the "https://": use the host only, for example "myapp.dl2.app".`);
+  if (/[/?#]/.test(host)) fail(`${where} is "${value}". Remove the path: use the host only, for example "myapp.dl2.app".`);
+  if (/:\d+$/.test(host)) fail(`${where} is "${value}". Remove the port: app links only work on the default HTTPS port.`);
+  if (!HOST.test(host)) fail(`${where} is "${value}", which is not a valid host name. Example: "myapp.dl2.app".`);
+  return host;
+}
+
+function checkBool(value: unknown, name: string, fallback: boolean): boolean {
+  if (value === undefined) return fallback;
+  if (typeof value !== "boolean") fail(`"${name}" must be true or false, got ${JSON.stringify(value)}.`);
+  return value as boolean;
+}
+
+/** Validates the plugin options and returns the full host list. Throws with a fix in the message. */
+export function normalizeOptions(raw: unknown): NormalizedOptions {
+  if (raw === undefined || raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+    fail(`Missing options. Use ["${NAME}", { "subdomain": "myapp" }] or ["${NAME}", { "domains": ["myapp.dl2.app", "myapp-alt.dl2.app"] }].`);
+  }
+  const o = raw as Record<string, unknown>;
+  for (const key of Object.keys(o)) {
+    if (ALLOWED.indexOf(key) < 0) fail(`Unknown option "${key}". Allowed options: ${ALLOWED.join(", ")}.`);
+  }
+
+  const domains: string[] = [];
+  const add = (h: string) => {
+    if (domains.indexOf(h) < 0) domains.push(h);
+  };
+
+  if (o.rootDomain !== undefined && o.subdomain === undefined) fail(`"rootDomain" only makes sense together with "subdomain".`);
+  if (o.subdomain !== undefined) {
+    if (typeof o.subdomain !== "string" || !LABEL.test(o.subdomain.trim().toLowerCase())) {
+      fail(`"subdomain" is ${JSON.stringify(o.subdomain)}. Use only the first part of your link host: "myapp" for myapp.dl2.app.`);
+    }
+    const sub = (o.subdomain as string).trim().toLowerCase();
+    if (/-alt$/.test(sub)) fail(`"subdomain" is "${sub}". Leave out "-alt": the alternate host is added for you.`);
+    const root = o.rootDomain === undefined ? "dl2.app" : checkHost(o.rootDomain, `"rootDomain"`);
+    add(`${sub}.${root}`);
+    add(`${sub}-alt.${root}`);
+  }
+
+  if (o.domains !== undefined) {
+    if (!Array.isArray(o.domains)) fail(`"domains" must be a list of host names, got ${JSON.stringify(o.domains)}.`);
+    (o.domains as unknown[]).forEach((d, i) => add(checkHost(d, `"domains[${i}]"`)));
+  }
+  if (!domains.length) fail(`No link hosts. Pass "subdomain" (your DL2 project subdomain) or a non-empty "domains" list.`);
+
+  let uriScheme: string | null = null;
+  if (o.uriScheme !== undefined) {
+    if (typeof o.uriScheme !== "string" || !o.uriScheme) fail(`"uriScheme" must be text such as "myapp".`);
+    const s = (o.uriScheme as string).replace(/:\/\/$/, "");
+    if (!SCHEME.test(s)) fail(`"uriScheme" is "${o.uriScheme}". Use lowercase letters, digits, "+", "-" or ".", starting with a letter, and no "://".`);
+    if (s === "http" || s === "https") fail(`"uriScheme" cannot be "${s}". Use a scheme of your own such as "myapp".`);
+    uriScheme = s;
+  }
+
+  return {
+    domains,
+    iosDeveloperMode: checkBool(o.iosDeveloperMode, "iosDeveloperMode", false),
+    androidAutoVerify: checkBool(o.androidAutoVerify, "androidAutoVerify", true),
+    uriScheme,
+  };
+}
+
+/** Adds `applinks:` entries, keeping every entry the app already has exactly as it is. */
+export function mergeAssociatedDomains(existing: unknown, domains: string[], developerMode: boolean): string[] {
+  const out: string[] = Array.isArray(existing) ? existing.filter((e): e is string => typeof e === "string") : [];
+  for (const d of domains) {
+    // A host the app already lists keeps its own mode: the option only applies to entries added here.
+    if (out.some((e) => e.split("?")[0].toLowerCase() === `applinks:${d}`)) continue;
+    out.push(`applinks:${d}${developerMode ? "?mode=developer" : ""}`);
+  }
+  return out;
+}
+
+function list<T>(v: T | T[] | undefined): T[] {
+  return v === undefined ? [] : Array.isArray(v) ? v : [v];
+}
+
+function isBrowsableView(f: IntentFilter): boolean {
+  return f.action === "VIEW" && list(f.category).indexOf("BROWSABLE") >= 0;
+}
+
+const RESTRICTIONS = ["port", "path", "pathPrefix", "pathPattern", "pathSuffix", "pathAdvancedPattern", "mimeType"];
+
+/** Android applies every path, port and type in a filter to all of its hosts, so one of them narrows the whole filter. */
+function isRestricted(f: IntentFilter): boolean {
+  return list(f.data).some((d) => RESTRICTIONS.some((k) => d[k] !== undefined && d[k] !== null && d[k] !== ""));
+}
+
+/** Adds one https intent filter for the hosts that are not covered yet, and one for the scheme. */
+export function mergeIntentFilters(existing: unknown, domains: string[], autoVerify: boolean, uriScheme: string | null): IntentFilter[] {
+  const out: IntentFilter[] = Array.isArray(existing) ? (existing as IntentFilter[]).slice() : [];
+  const covered = new Set<string>();
+  const schemes = new Set<string>();
+  for (const f of out) {
+    if (!f || !isBrowsableView(f)) continue;
+    // A filter limited to some paths does not open every link of the host.
+    const open = !isRestricted(f);
+    for (const d of list(f.data)) {
+      if (open && d.scheme === "https" && typeof d.host === "string" && (!autoVerify || f.autoVerify === true)) covered.add(d.host.toLowerCase());
+      if (d.scheme && !d.host) schemes.add(d.scheme);
+    }
+  }
+  const missing = domains.filter((d) => !covered.has(d));
+  if (missing.length) {
+    const filter: IntentFilter = {
+      action: "VIEW",
+      data: missing.map((host) => ({ scheme: "https", host })),
+      category: ["BROWSABLE", "DEFAULT"],
+    };
+    if (autoVerify) filter.autoVerify = true;
+    out.push(filter);
+  }
+  if (uriScheme && !schemes.has(uriScheme)) {
+    out.push({ action: "VIEW", data: [{ scheme: uriScheme }], category: ["BROWSABLE", "DEFAULT"] });
+  }
+  return out;
+}
+
+export function mergeSchemes(existing: unknown, uriScheme: string | null): string | string[] | undefined {
+  const current = list(existing as string | string[] | undefined).filter((s) => typeof s === "string");
+  if (!uriScheme || current.indexOf(uriScheme) >= 0) return existing as string | string[] | undefined;
+  return current.length ? current.concat(uriScheme) : uriScheme;
+}
+
+/** The whole plugin as a pure function. Does not modify its input. */
+export function applyDL2<T extends object>(config: T, rawOptions: unknown): T & ExpoConfigLike {
+  const input = config as ExpoConfigLike;
+  const o = normalizeOptions(rawOptions);
+  const next: ExpoConfigLike = { ...input };
+  next.ios = { ...(input.ios || {}), associatedDomains: mergeAssociatedDomains(input.ios?.associatedDomains, o.domains, o.iosDeveloperMode) };
+  next.android = {
+    ...(input.android || {}),
+    intentFilters: mergeIntentFilters(input.android?.intentFilters, o.domains, o.androidAutoVerify, o.uriScheme),
+  };
+  const scheme = mergeSchemes(input.scheme, o.uriScheme);
+  if (scheme !== undefined) next.scheme = scheme;
+  return next as T & ExpoConfigLike;
+}
+
+const withDL2 = <T extends object>(config: T, options: DL2PluginOptions): T & ExpoConfigLike => applyDL2(config, options);
+
+export default withDL2;