@symbiote-native/web-browser 0.0.1

package/build/core/web-browser.js

@@ -0,0 +1,256 @@
+// Hand-ported from .vendors/expo/packages/expo-web-browser/src/WebBrowser.ts (sdk-57). Two
+// deliberate departures from upstream, both because SymbioteNative has no web target:
+// `maybeCompleteAuthSession` is not ported (it exists only to close a `window.open` popup; on a
+// native platform it can do nothing but return `{ type: 'failed' }`), and the web-only open
+// options are gone from IWebBrowserOpenOptions.
+import { Platform, UnavailabilityError } from 'expo-modules-core';
+import { AppState, Linking, processColor } from 'react-native';
+import { expoWebBrowser } from './native-module';
+import { WebBrowserResultType, } from './types';
+const NATIVE_MODULE_NAME = 'expo-web-browser';
+const EMPTY_CUSTOM_TABS_PACKAGES = {
+    defaultBrowserPackage: undefined,
+    preferredBrowserPackage: undefined,
+    browserPackages: [],
+    servicePackages: [],
+};
+/**
+ * The packages that support Custom Tabs, the Custom Tabs service, and the user's chosen and
+ * preferred browser. Only as reliable as `PackageManager.getResolvingActivities` underneath — a
+ * browser can be missing from `browserPackages` once another one is set as default.
+ *
+ * @platform android
+ */
+export async function getCustomTabsSupportingBrowsersAsync() {
+    // iOS registers its no-op stub as `getCustomTabsSupportingBrowsers`, without the `Async`
+    // suffix, so this guard — kept in upstream's order deliberately — fires there before the
+    // non-Android early return below can be reached.
+    if (!expoWebBrowser.getCustomTabsSupportingBrowsersAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'getCustomTabsSupportingBrowsersAsync');
+    }
+    if (Platform.OS !== 'android') {
+        return EMPTY_CUSTOM_TABS_PACKAGES;
+    }
+    return expoWebBrowser.getCustomTabsSupportingBrowsersAsync();
+}
+/**
+ * Calls `warmUp` on the [`CustomTabsClient`](https://developer.android.com/reference/androidx/browser/customtabs/CustomTabsClient#warmup(long))
+ * for the given package.
+ *
+ * @param browserPackage Browser to warm up. Defaults to the preferred one.
+ * @platform android
+ */
+export async function warmUpAsync(browserPackage) {
+    if (!expoWebBrowser.warmUpAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'warmUpAsync');
+    }
+    if (Platform.OS !== 'android') {
+        return {};
+    }
+    return expoWebBrowser.warmUpAsync(browserPackage);
+}
+/**
+ * Starts a [`CustomTabsSession`](https://developer.android.com/reference/androidx/browser/customtabs/CustomTabsSession#mayLaunchUrl(android.net.Uri,android.os.Bundle,java.util.List%3Candroid.os.Bundle%3E))
+ * if needed and calls its `mayLaunchUrl`, so the browser can prefetch the page.
+ *
+ * @param url The page most likely to be opened first.
+ * @param browserPackage Browser to inform. Defaults to the preferred one.
+ * @platform android
+ */
+export async function mayInitWithUrlAsync(url, browserPackage) {
+    if (!expoWebBrowser.mayInitWithUrlAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'mayInitWithUrlAsync');
+    }
+    if (Platform.OS !== 'android') {
+        return {};
+    }
+    return expoWebBrowser.mayInitWithUrlAsync(url, browserPackage);
+}
+/**
+ * Drops every binding `warmUpAsync` and `mayInitWithUrlAsync` created. Call it once the bindings
+ * are no longer needed to avoid leaking them — though they are also released when the app is
+ * destroyed, which is often good enough.
+ *
+ * @param browserPackage Browser to cool down. Defaults to the preferred one.
+ * @returns The cooled service, or an empty object when there was no connection to dismiss.
+ * @platform android
+ */
+export async function coolDownAsync(browserPackage) {
+    if (!expoWebBrowser.coolDownAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'coolDownAsync');
+    }
+    if (Platform.OS !== 'android') {
+        return {};
+    }
+    return expoWebBrowser.coolDownAsync(browserPackage);
+}
+/**
+ * Opens the url in a modal [`SFSafariViewController`](https://developer.apple.com/documentation/safariservices/sfsafariviewcontroller)
+ * on iOS and a [Custom Tab](https://developer.chrome.com/docs/android/custom-tabs) on Android. The
+ * modal Safari does not share cookies with the system Safari — for a login flow that needs them,
+ * use `openAuthSessionAsync`.
+ *
+ * @returns Android resolves with `{ type: 'opened' }` as soon as the tab launches, without waiting
+ * for the user to close it. iOS resolves with `{ type: 'cancel' }` when the user dismissed the
+ * browser and `{ type: 'dismiss' }` when `dismissBrowser` closed it.
+ */
+export async function openBrowserAsync(url, browserParams = {}) {
+    if (!expoWebBrowser.openBrowserAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'openBrowserAsync');
+    }
+    return expoWebBrowser.openBrowserAsync(url, processOptions(browserParams));
+}
+/**
+ * Dismisses the presented browser. Throws where dismissing isn't available — Android's Custom Tabs
+ * offer no way to close a tab programmatically, so there the user has to press the tab's own close
+ * button.
+ *
+ * @platform ios
+ */
+export function dismissBrowser() {
+    if (!expoWebBrowser.dismissBrowser) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'dismissBrowser');
+    }
+    return expoWebBrowser.dismissBrowser();
+}
+/**
+ * Opens a login page and resolves once the authentication provider redirects back to the app.
+ *
+ * On iOS this is `ASWebAuthenticationSession`, which asks the user whether the app may
+ * authenticate with the given url; the redirect URI registered with the authentication server has
+ * to use the app's own scheme (`demo://…`, not `https://…`). Adding a `Linking` listener of your
+ * own is unnecessary there and can have side effects.
+ *
+ * Android has no equivalent native API, so it is polyfilled: a Custom Tab plus `AppState` and
+ * `Linking`, racing "the deep link came back" against "the app returned to the foreground". Only
+ * one such session can be open at a time.
+ *
+ * @param url The login page to open.
+ * @param redirectUrl The url that deep-links back into the app. Without it the session can only
+ * end by the user closing the browser.
+ * @returns `{ type: 'success', url }` with the redirect url on a completed login,
+ * `{ type: 'cancel' }` when the user declined or closed the browser, and `{ type: 'dismiss' }` when
+ * `dismissBrowser` closed it.
+ */
+export async function openAuthSessionAsync(url, redirectUrl, options = {}) {
+    if (!isAuthSessionNativelySupported()) {
+        return openAuthSessionPolyfillAsync(url, redirectUrl, options);
+    }
+    if (!expoWebBrowser.openAuthSessionAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'openAuthSessionAsync');
+    }
+    return expoWebBrowser.openAuthSessionAsync(url, redirectUrl, processOptions(options));
+}
+/**
+ * Dismisses the current authentication session. Falls back to dismissing the plain browser where
+ * there is no native auth session, which on Android throws for the same reason `dismissBrowser`
+ * does.
+ *
+ * @platform ios
+ */
+export function dismissAuthSession() {
+    if (isAuthSessionNativelySupported()) {
+        if (!expoWebBrowser.dismissAuthSession) {
+            throw new UnavailabilityError(NATIVE_MODULE_NAME, 'dismissAuthSession');
+        }
+        expoWebBrowser.dismissAuthSession();
+        return;
+    }
+    if (!expoWebBrowser.dismissBrowser) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'dismissBrowser');
+    }
+    void expoWebBrowser.dismissBrowser();
+}
+function processOptions(options) {
+    return {
+        ...options,
+        controlsColor: processColor(options.controlsColor),
+        toolbarColor: processColor(options.toolbarColor),
+        secondaryToolbarColor: processColor(options.secondaryToolbarColor),
+    };
+}
+/* Android polyfill for the ASWebAuthenticationSession flow */
+function isAuthSessionNativelySupported() {
+    return Platform.OS !== 'android';
+}
+let redirectSubscription = null;
+// `openBrowserAsync` on Android resolves the moment the Custom Tab launches, not when the user
+// closes it, so the polyfill has to watch AppState instead. This holds the `resolve` of the
+// promise that waits for the app to come back to the foreground.
+let onWebBrowserCloseAndroid = null;
+// A null initial `AppState.currentState` means the first `change` event is the bridge reporting
+// the state it captured, not a real transition — that one has to be ignored, or the session would
+// end the instant it started. See https://reactnative.dev/docs/appstate#basic-usage.
+let isAppStateAvailable = AppState.currentState !== null;
+function onAppStateChangeAndroid(state) {
+    if (!isAppStateAvailable) {
+        isAppStateAvailable = true;
+        return;
+    }
+    if (state === 'active' && onWebBrowserCloseAndroid) {
+        onWebBrowserCloseAndroid();
+    }
+}
+async function openBrowserAndWaitAndroidAsync(startUrl, browserParams = {}) {
+    const appStateChangedToActive = new Promise(resolve => {
+        onWebBrowserCloseAndroid = resolve;
+    });
+    const stateChangeSubscription = AppState.addEventListener('change', onAppStateChangeAndroid);
+    let launched;
+    try {
+        launched = await openBrowserAsync(startUrl, browserParams);
+    }
+    catch (error) {
+        stateChangeSubscription.remove();
+        onWebBrowserCloseAndroid = null;
+        throw error;
+    }
+    let result = { type: WebBrowserResultType.CANCEL };
+    if (launched.type === WebBrowserResultType.OPENED) {
+        await appStateChangedToActive;
+        result = { type: WebBrowserResultType.DISMISS };
+    }
+    stateChangeSubscription.remove();
+    onWebBrowserCloseAndroid = null;
+    return result;
+}
+async function openAuthSessionPolyfillAsync(startUrl, returnUrl, browserParams = {}) {
+    if (redirectSubscription) {
+        throw new Error("The WebBrowser's auth session is in an invalid state with a redirect handler set when it should not be");
+    }
+    if (onWebBrowserCloseAndroid) {
+        throw new Error('WebBrowser is already open, only one can be open at a time');
+    }
+    try {
+        return await Promise.race([
+            openBrowserAndWaitAndroidAsync(startUrl, browserParams),
+            waitForRedirectAsync(returnUrl),
+        ]);
+    }
+    finally {
+        // Only reachable on a platform that can dismiss a browser at all — Android users have to
+        // close the Custom Tab themselves.
+        if (expoWebBrowser.dismissBrowser) {
+            void expoWebBrowser.dismissBrowser();
+        }
+        stopWaitingForRedirect();
+    }
+}
+function stopWaitingForRedirect() {
+    if (!redirectSubscription) {
+        throw new Error('The WebBrowser auth session is in an invalid state with no redirect handler when one should be set');
+    }
+    redirectSubscription.remove();
+    redirectSubscription = null;
+}
+function waitForRedirectAsync(returnUrl) {
+    // Deliberately never resolves when `returnUrl` is nullish: the browser promise it is raced
+    // against is then the only thing that can settle the session.
+    return new Promise(resolve => {
+        redirectSubscription = Linking.addEventListener('url', (event) => {
+            if (returnUrl && event.url.startsWith(returnUrl)) {
+                resolve({ url: event.url, type: 'success' });
+            }
+        });
+    });
+}

package/build/react/index.d.ts

@@ -0,0 +1 @@
+export * from '../core';

package/build/react/index.js

@@ -0,0 +1,7 @@
+// @symbiote-native/web-browser/react: the React entry over the framework-agnostic core.
+// Every export is a stateless free function. The one piece of live state — the Android
+// auth-session polyfill's redirect subscription — belongs to a single in-flight promise inside the
+// core and never surfaces as something a caller subscribes to or tears down, so there is nothing
+// for a hook to wrap. Hence a plain re-export, the same shape packages/secure-store's React entry
+// has for the same reason.
+export * from '../core';

package/build/vue/index.d.ts

@@ -0,0 +1 @@
+export * from '../core';

package/build/vue/index.js

@@ -0,0 +1,4 @@
+// @symbiote-native/web-browser/vue: the Vue entry over the framework-agnostic core.
+// Nothing here holds per-instance state or hands back a subscription, so there is no lifecycle for
+// a composable to own — see the React entry for the full reasoning.
+export * from '../core';

package/build-ngc/angular/index.d.ts

@@ -0,0 +1 @@
+export * from '../core';

package/build-ngc/angular/index.js

@@ -0,0 +1,5 @@
+// @symbiote-native/web-browser/angular: the Angular entry over the framework-agnostic core.
+// Nothing here holds per-instance state or hands back a subscription, so there is no lifecycle for
+// an injectable service to own — see the React entry for the full reasoning.
+export * from '../core';
+//# sourceMappingURL=index.js.map

package/build-ngc/angular/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/angular/index.ts"],"names":[],"mappings":"AAAA,4FAA4F;AAC5F,mGAAmG;AACnG,6EAA6E;AAC7E,cAAc,SAAS,CAAC"}

package/build-ngc/core/index.d.ts

@@ -0,0 +1,3 @@
+export { getCustomTabsSupportingBrowsersAsync, warmUpAsync, mayInitWithUrlAsync, coolDownAsync, openBrowserAsync, dismissBrowser, openAuthSessionAsync, dismissAuthSession, } from './web-browser';
+export { WebBrowserResultType, WebBrowserPresentationStyle } from './types';
+export type { IAuthSessionOpenOptions, IRedirectEvent, IServiceActionResult, IWebBrowserAuthSessionResult, IWebBrowserCoolDownResult, IWebBrowserCustomTabsResults, IWebBrowserDismissResult, IWebBrowserMayInitWithUrlResult, IWebBrowserOpenOptions, IWebBrowserRedirectResult, IWebBrowserResult, IWebBrowserWarmUpResult, } from './types';

package/build-ngc/core/index.js

@@ -0,0 +1,3 @@
+export { getCustomTabsSupportingBrowsersAsync, warmUpAsync, mayInitWithUrlAsync, coolDownAsync, openBrowserAsync, dismissBrowser, openAuthSessionAsync, dismissAuthSession, } from './web-browser';
+export { WebBrowserResultType, WebBrowserPresentationStyle } from './types';
+//# sourceMappingURL=index.js.map

package/build-ngc/core/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,oCAAoC,EACpC,WAAW,EACX,mBAAmB,EACnB,aAAa,EACb,gBAAgB,EAChB,cAAc,EACd,oBAAoB,EACpB,kBAAkB,GACnB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,oBAAoB,EAAE,2BAA2B,EAAE,MAAM,SAAS,CAAC"}

package/build-ngc/core/native-module.d.ts

@@ -0,0 +1,12 @@
+import type { IProcessedOpenOptions, IWebBrowserAuthSessionResult, IWebBrowserCoolDownResult, IWebBrowserCustomTabsResults, IWebBrowserDismissResult, IWebBrowserMayInitWithUrlResult, IWebBrowserResult, IWebBrowserWarmUpResult } from './types';
+export type INativeWebBrowserModule = {
+    openBrowserAsync?(url: string, options: IProcessedOpenOptions): Promise<IWebBrowserResult>;
+    dismissBrowser?(): Promise<IWebBrowserDismissResult>;
+    openAuthSessionAsync?(url: string, redirectUrl: string | null | undefined, options: IProcessedOpenOptions): Promise<IWebBrowserAuthSessionResult>;
+    dismissAuthSession?(): void;
+    warmUpAsync?(browserPackage?: string): Promise<IWebBrowserWarmUpResult>;
+    coolDownAsync?(browserPackage?: string): Promise<IWebBrowserCoolDownResult>;
+    mayInitWithUrlAsync?(url: string, browserPackage?: string): Promise<IWebBrowserMayInitWithUrlResult>;
+    getCustomTabsSupportingBrowsersAsync?(): Promise<IWebBrowserCustomTabsResults>;
+};
+export declare const expoWebBrowser: INativeWebBrowserModule;

package/build-ngc/core/native-module.js

@@ -0,0 +1,4 @@
+import { requireNativeModule } from 'expo-modules-core';
+const EXPO_WEB_BROWSER_MODULE_NAME = 'ExpoWebBrowser';
+export const expoWebBrowser = requireNativeModule(EXPO_WEB_BROWSER_MODULE_NAME);
+//# sourceMappingURL=native-module.js.map

package/build-ngc/core/native-module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-module.js","sourceRoot":"","sources":["../../src/core/native-module.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAYxD,MAAM,4BAA4B,GAAG,gBAAgB,CAAC;AA4BtD,MAAM,CAAC,MAAM,cAAc,GAAG,mBAAmB,CAC/C,4BAA4B,CAC7B,CAAC"}

package/build-ngc/core/types.d.ts

@@ -0,0 +1,193 @@
+import type { ProcessedColorValue } from 'react-native';
+/** Payload of the deep-link event the Android auth-session polyfill listens for. */
+export type IRedirectEvent = {
+    url: string;
+};
+/**
+ * Options for [`openBrowserAsync`](#openbrowserasync).
+ *
+ * Upstream's two `@platform web` fields (`windowName`, `windowFeatures`) are not part of this
+ * type — SymbioteNative has no web target, so they could never be read.
+ */
+export type IWebBrowserOpenOptions = {
+    /** Color of the toolbar. Accepts any React Native color format. */
+    toolbarColor?: string;
+    /**
+     * Package name of the browser that should handle the Custom Tab. Pick one from
+     * `getCustomTabsSupportingBrowsersAsync`.
+     * @platform android
+     */
+    browserPackage?: string;
+    /** Whether the toolbar hides as the user scrolls the page. */
+    enableBarCollapsing?: boolean;
+    /**
+     * Color of the secondary toolbar. Accepts any React Native color format.
+     * @platform android
+     */
+    secondaryToolbarColor?: string;
+    /**
+     * Whether the toolbar shows the website's title.
+     * @platform android
+     */
+    showTitle?: boolean;
+    /**
+     * Whether a default share item is added to the browser's menu.
+     * @platform android
+     */
+    enableDefaultShareMenuItem?: boolean;
+    /**
+     * Whether the browsed website appears as its own entry in the recents/multitasking view.
+     * Requires `createTask` to stay `true`.
+     * @default false
+     * @platform android
+     */
+    showInRecents?: boolean;
+    /**
+     * Whether the browser opens in its own task rather than the app's.
+     * @default true
+     * @platform android
+     */
+    createTask?: boolean;
+    /**
+     * Whether to launch the browser through a transparent proxy activity with a different task
+     * affinity, which keeps the browser alive while the app is backgrounded. Only read when
+     * `createTask` is `true`, and forces `showInRecents` on. Set `false` for the legacy direct
+     * launch.
+     * @default true
+     * @platform android
+     */
+    useProxyActivity?: boolean;
+    /**
+     * Tint color for the controls in `SFSafariViewController`. Accepts any React Native color
+     * format.
+     * @platform ios
+     */
+    controlsColor?: string;
+    /**
+     * Style of the dismiss button.
+     * @platform ios
+     */
+    dismissButtonStyle?: 'done' | 'close' | 'cancel';
+    /**
+     * Whether Safari should enter Reader mode when the page supports it.
+     * @platform ios
+     */
+    readerMode?: boolean;
+    /**
+     * [Presentation style](https://developer.apple.com/documentation/uikit/uiviewcontroller/1621355-modalpresentationstyle)
+     * of the browser window.
+     * @default WebBrowserPresentationStyle.OVER_FULL_SCREEN
+     * @platform ios
+     */
+    presentationStyle?: WebBrowserPresentationStyle;
+};
+/**
+ * Options for [`openAuthSessionAsync`](#openauthsessionasync). Android has no native auth-session
+ * API, so there the inherited `IWebBrowserOpenOptions` fields are passed to the Custom Tab the
+ * polyfill opens; on iOS `ASWebAuthenticationSession` ignores them and reads only the two fields
+ * below.
+ */
+export type IAuthSessionOpenOptions = IWebBrowserOpenOptions & {
+    /**
+     * Ask the browser for a private authentication session, so it shares no cookies or browsing
+     * data with the user's normal session. Whether the request is honored is up to the user's
+     * default browser.
+     * @default false
+     * @platform ios
+     */
+    preferEphemeralSession?: boolean;
+    /**
+     * Use HTTPS universal-link callbacks instead of custom-URL-scheme callbacks. Needs the
+     * Associated Domains entitlement configured for the redirect URL's host, and iOS 17.4+. Left
+     * `false`, the legacy `callbackURLScheme` API is used, which needs no entitlement.
+     * @default false
+     * @platform ios
+     */
+    preferUniversalLinks?: boolean;
+};
+/**
+ * The open options after the three color fields have been run through `processColor`. This is the
+ * shape the native module actually receives — a color reaches native as a platform integer, never
+ * as the CSS string the caller wrote.
+ */
+export type IProcessedOpenOptions = Omit<IAuthSessionOpenOptions, 'toolbarColor' | 'secondaryToolbarColor' | 'controlsColor'> & {
+    toolbarColor?: ProcessedColorValue | null;
+    secondaryToolbarColor?: ProcessedColorValue | null;
+    controlsColor?: ProcessedColorValue | null;
+};
+export type IWebBrowserCustomTabsResults = {
+    /**
+     * The browser the user picked as their device default, or `undefined` when there is none — which
+     * usually means the user will be prompted to choose.
+     */
+    defaultBrowserPackage?: string;
+    /**
+     * The browser `CustomTabsClient` prefers for Custom Tabs. Favors the user's default as long as
+     * it appears in both `browserPackages` and `servicePackages`; only such browsers fully support
+     * Custom Tabs. `undefined` when no installed browser qualifies.
+     */
+    preferredBrowserPackage?: string;
+    /**
+     * Every package `PackageManager` recognizes as able to handle Custom Tabs. Empty when the device
+     * has no supporting browser.
+     */
+    browserPackages: string[];
+    /**
+     * Every package `PackageManager` recognizes as able to handle the Custom Tabs *Service* — the
+     * one `warmUpAsync`, `mayInitWithUrlAsync` and `coolDownAsync` talk to.
+     */
+    servicePackages: string[];
+};
+/** How a browser session ended. */
+export declare enum WebBrowserResultType {
+    /** The user dismissed the browser themselves. @platform ios */
+    CANCEL = "cancel",
+    /** The browser was closed by a `dismissBrowser` call. @platform ios */
+    DISMISS = "dismiss",
+    /** The browser was launched. Android resolves here without waiting for it to close. @platform android */
+    OPENED = "opened",
+    /** Another browser session is already in progress. */
+    LOCKED = "locked"
+}
+/**
+ * A browser presentation style, mapped directly onto
+ * [`UIModalPresentationStyle`](https://developer.apple.com/documentation/uikit/uiviewcontroller/1621355-modalpresentationstyle).
+ *
+ * @platform ios
+ */
+export declare enum WebBrowserPresentationStyle {
+    /** The browser covers the screen. */
+    FULL_SCREEN = "fullScreen",
+    /** The browser partially covers the underlying content. */
+    PAGE_SHEET = "pageSheet",
+    /** The browser is centered on the screen. */
+    FORM_SHEET = "formSheet",
+    /** The browser is displayed over the app's content. */
+    CURRENT_CONTEXT = "currentContext",
+    /** The browser view covers the screen. */
+    OVER_FULL_SCREEN = "overFullScreen",
+    /** The browser is displayed over the app's content. */
+    OVER_CURRENT_CONTEXT = "overCurrentContext",
+    /** The browser is displayed in a popover view. */
+    POPOVER = "popover",
+    /** The system picks the style. Older iOS versions fall back to `FULL_SCREEN`. */
+    AUTOMATIC = "automatic"
+}
+export type IWebBrowserResult = {
+    type: WebBrowserResultType;
+};
+/** What `dismissBrowser` resolves with once the presented browser has been torn down. */
+export type IWebBrowserDismissResult = {
+    type: WebBrowserResultType.DISMISS;
+};
+export type IWebBrowserRedirectResult = {
+    type: 'success';
+    url: string;
+};
+export type IServiceActionResult = {
+    servicePackage?: string;
+};
+export type IWebBrowserAuthSessionResult = IWebBrowserRedirectResult | IWebBrowserResult;
+export type IWebBrowserMayInitWithUrlResult = IServiceActionResult;
+export type IWebBrowserWarmUpResult = IServiceActionResult;
+export type IWebBrowserCoolDownResult = IServiceActionResult;

package/build-ngc/core/types.js

@@ -0,0 +1,38 @@
+/** How a browser session ended. */
+export var WebBrowserResultType;
+(function (WebBrowserResultType) {
+    /** The user dismissed the browser themselves. @platform ios */
+    WebBrowserResultType["CANCEL"] = "cancel";
+    /** The browser was closed by a `dismissBrowser` call. @platform ios */
+    WebBrowserResultType["DISMISS"] = "dismiss";
+    /** The browser was launched. Android resolves here without waiting for it to close. @platform android */
+    WebBrowserResultType["OPENED"] = "opened";
+    /** Another browser session is already in progress. */
+    WebBrowserResultType["LOCKED"] = "locked";
+})(WebBrowserResultType || (WebBrowserResultType = {}));
+/**
+ * A browser presentation style, mapped directly onto
+ * [`UIModalPresentationStyle`](https://developer.apple.com/documentation/uikit/uiviewcontroller/1621355-modalpresentationstyle).
+ *
+ * @platform ios
+ */
+export var WebBrowserPresentationStyle;
+(function (WebBrowserPresentationStyle) {
+    /** The browser covers the screen. */
+    WebBrowserPresentationStyle["FULL_SCREEN"] = "fullScreen";
+    /** The browser partially covers the underlying content. */
+    WebBrowserPresentationStyle["PAGE_SHEET"] = "pageSheet";
+    /** The browser is centered on the screen. */
+    WebBrowserPresentationStyle["FORM_SHEET"] = "formSheet";
+    /** The browser is displayed over the app's content. */
+    WebBrowserPresentationStyle["CURRENT_CONTEXT"] = "currentContext";
+    /** The browser view covers the screen. */
+    WebBrowserPresentationStyle["OVER_FULL_SCREEN"] = "overFullScreen";
+    /** The browser is displayed over the app's content. */
+    WebBrowserPresentationStyle["OVER_CURRENT_CONTEXT"] = "overCurrentContext";
+    /** The browser is displayed in a popover view. */
+    WebBrowserPresentationStyle["POPOVER"] = "popover";
+    /** The system picks the style. Older iOS versions fall back to `FULL_SCREEN`. */
+    WebBrowserPresentationStyle["AUTOMATIC"] = "automatic";
+})(WebBrowserPresentationStyle || (WebBrowserPresentationStyle = {}));
+//# sourceMappingURL=types.js.map

package/build-ngc/core/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/core/types.ts"],"names":[],"mappings":"AAqJA,mCAAmC;AACnC,MAAM,CAAN,IAAY,oBASX;AATD,WAAY,oBAAoB;IAC9B,+DAA+D;IAC/D,yCAAiB,CAAA;IACjB,uEAAuE;IACvE,2CAAmB,CAAA;IACnB,yGAAyG;IACzG,yCAAiB,CAAA;IACjB,sDAAsD;IACtD,yCAAiB,CAAA;AACnB,CAAC,EATW,oBAAoB,KAApB,oBAAoB,QAS/B;AAED;;;;;GAKG;AACH,MAAM,CAAN,IAAY,2BAiBX;AAjBD,WAAY,2BAA2B;IACrC,qCAAqC;IACrC,yDAA0B,CAAA;IAC1B,2DAA2D;IAC3D,uDAAwB,CAAA;IACxB,6CAA6C;IAC7C,uDAAwB,CAAA;IACxB,uDAAuD;IACvD,iEAAkC,CAAA;IAClC,0CAA0C;IAC1C,kEAAmC,CAAA;IACnC,uDAAuD;IACvD,0EAA2C,CAAA;IAC3C,kDAAkD;IAClD,kDAAmB,CAAA;IACnB,iFAAiF;IACjF,sDAAuB,CAAA;AACzB,CAAC,EAjBW,2BAA2B,KAA3B,2BAA2B,QAiBtC"}

package/build-ngc/core/web-browser.d.ts

@@ -0,0 +1,83 @@
+import { type IAuthSessionOpenOptions, type IWebBrowserAuthSessionResult, type IWebBrowserCoolDownResult, type IWebBrowserCustomTabsResults, type IWebBrowserDismissResult, type IWebBrowserMayInitWithUrlResult, type IWebBrowserOpenOptions, type IWebBrowserResult, type IWebBrowserWarmUpResult } from './types';
+/**
+ * The packages that support Custom Tabs, the Custom Tabs service, and the user's chosen and
+ * preferred browser. Only as reliable as `PackageManager.getResolvingActivities` underneath — a
+ * browser can be missing from `browserPackages` once another one is set as default.
+ *
+ * @platform android
+ */
+export declare function getCustomTabsSupportingBrowsersAsync(): Promise<IWebBrowserCustomTabsResults>;
+/**
+ * Calls `warmUp` on the [`CustomTabsClient`](https://developer.android.com/reference/androidx/browser/customtabs/CustomTabsClient#warmup(long))
+ * for the given package.
+ *
+ * @param browserPackage Browser to warm up. Defaults to the preferred one.
+ * @platform android
+ */
+export declare function warmUpAsync(browserPackage?: string): Promise<IWebBrowserWarmUpResult>;
+/**
+ * Starts a [`CustomTabsSession`](https://developer.android.com/reference/androidx/browser/customtabs/CustomTabsSession#mayLaunchUrl(android.net.Uri,android.os.Bundle,java.util.List%3Candroid.os.Bundle%3E))
+ * if needed and calls its `mayLaunchUrl`, so the browser can prefetch the page.
+ *
+ * @param url The page most likely to be opened first.
+ * @param browserPackage Browser to inform. Defaults to the preferred one.
+ * @platform android
+ */
+export declare function mayInitWithUrlAsync(url: string, browserPackage?: string): Promise<IWebBrowserMayInitWithUrlResult>;
+/**
+ * Drops every binding `warmUpAsync` and `mayInitWithUrlAsync` created. Call it once the bindings
+ * are no longer needed to avoid leaking them — though they are also released when the app is
+ * destroyed, which is often good enough.
+ *
+ * @param browserPackage Browser to cool down. Defaults to the preferred one.
+ * @returns The cooled service, or an empty object when there was no connection to dismiss.
+ * @platform android
+ */
+export declare function coolDownAsync(browserPackage?: string): Promise<IWebBrowserCoolDownResult>;
+/**
+ * Opens the url in a modal [`SFSafariViewController`](https://developer.apple.com/documentation/safariservices/sfsafariviewcontroller)
+ * on iOS and a [Custom Tab](https://developer.chrome.com/docs/android/custom-tabs) on Android. The
+ * modal Safari does not share cookies with the system Safari — for a login flow that needs them,
+ * use `openAuthSessionAsync`.
+ *
+ * @returns Android resolves with `{ type: 'opened' }` as soon as the tab launches, without waiting
+ * for the user to close it. iOS resolves with `{ type: 'cancel' }` when the user dismissed the
+ * browser and `{ type: 'dismiss' }` when `dismissBrowser` closed it.
+ */
+export declare function openBrowserAsync(url: string, browserParams?: IWebBrowserOpenOptions): Promise<IWebBrowserResult>;
+/**
+ * Dismisses the presented browser. Throws where dismissing isn't available — Android's Custom Tabs
+ * offer no way to close a tab programmatically, so there the user has to press the tab's own close
+ * button.
+ *
+ * @platform ios
+ */
+export declare function dismissBrowser(): Promise<IWebBrowserDismissResult>;
+/**
+ * Opens a login page and resolves once the authentication provider redirects back to the app.
+ *
+ * On iOS this is `ASWebAuthenticationSession`, which asks the user whether the app may
+ * authenticate with the given url; the redirect URI registered with the authentication server has
+ * to use the app's own scheme (`demo://…`, not `https://…`). Adding a `Linking` listener of your
+ * own is unnecessary there and can have side effects.
+ *
+ * Android has no equivalent native API, so it is polyfilled: a Custom Tab plus `AppState` and
+ * `Linking`, racing "the deep link came back" against "the app returned to the foreground". Only
+ * one such session can be open at a time.
+ *
+ * @param url The login page to open.
+ * @param redirectUrl The url that deep-links back into the app. Without it the session can only
+ * end by the user closing the browser.
+ * @returns `{ type: 'success', url }` with the redirect url on a completed login,
+ * `{ type: 'cancel' }` when the user declined or closed the browser, and `{ type: 'dismiss' }` when
+ * `dismissBrowser` closed it.
+ */
+export declare function openAuthSessionAsync(url: string, redirectUrl?: string | null, options?: IAuthSessionOpenOptions): Promise<IWebBrowserAuthSessionResult>;
+/**
+ * Dismisses the current authentication session. Falls back to dismissing the plain browser where
+ * there is no native auth session, which on Android throws for the same reason `dismissBrowser`
+ * does.
+ *
+ * @platform ios
+ */
+export declare function dismissAuthSession(): void;