@microsoft/power-apps-native-host 0.2.22 → 0.3.0

package/lib/module/provider/SessionDetailsGesture.js

@@ -0,0 +1,211 @@
+"use strict";
+
+import React, { useCallback, useMemo, useState } from 'react';
+import { Modal, Platform, Pressable, StyleSheet, Text, View } from 'react-native';
+import * as Clipboard from 'expo-clipboard';
+import { Gesture, GestureDetector } from 'react-native-gesture-handler';
+import { getAppLogger } from "../telemetry/index.js";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+const SWIPE_DISTANCE = 80;
+export function SessionDetailsGesture({
+  enabled,
+  appName,
+  appId,
+  environmentId,
+  region,
+  appVersion,
+  children
+}) {
+  const [visible, setVisible] = useState(false);
+  const [sessionId, setSessionId] = useState();
+  const [copied, setCopied] = useState(false);
+  const showSessionDetails = useCallback(() => {
+    setSessionId(getAppLogger().sessionId);
+    setCopied(false);
+    setVisible(true);
+  }, []);
+  const gesture = useMemo(() => Gesture.Pan().enabled(enabled && Platform.OS !== 'web').minPointers(3).maxPointers(3).runOnJS(true).onEnd(({
+    translationX,
+    translationY
+  }) => {
+    if (translationY >= SWIPE_DISTANCE && translationY > Math.abs(translationX)) {
+      showSessionDetails();
+    }
+  }), [enabled, showSessionDetails]);
+  const close = useCallback(() => setVisible(false), []);
+  const copySessionId = useCallback(async () => {
+    if (!sessionId) return;
+    await Clipboard.setStringAsync(sessionId);
+    setCopied(true);
+  }, [sessionId]);
+  return /*#__PURE__*/_jsxs(_Fragment, {
+    children: [/*#__PURE__*/_jsx(GestureDetector, {
+      gesture: gesture,
+      children: /*#__PURE__*/_jsx(View, {
+        style: styles.content,
+        children: children
+      })
+    }), /*#__PURE__*/_jsx(Modal, {
+      animationType: "fade",
+      onRequestClose: close,
+      transparent: true,
+      visible: visible,
+      children: /*#__PURE__*/_jsx(Pressable, {
+        accessibilityRole: "button",
+        accessibilityLabel: "Close session details",
+        onPress: close,
+        style: styles.backdrop,
+        children: /*#__PURE__*/_jsxs(Pressable, {
+          accessible: false,
+          onPress: event => event.stopPropagation(),
+          style: styles.panel,
+          children: [/*#__PURE__*/_jsx(Text, {
+            style: styles.title,
+            children: "Session details"
+          }), /*#__PURE__*/_jsx(SessionDetail, {
+            label: "Telemetry session ID",
+            value: sessionId ?? 'Not available',
+            selectable: true,
+            singleLine: true
+          }), /*#__PURE__*/_jsx(Pressable, {
+            accessibilityRole: "button",
+            disabled: !sessionId,
+            onPress: () => {
+              void copySessionId();
+            },
+            style: ({
+              pressed
+            }) => [styles.copyButton, !sessionId && styles.disabledButton, pressed && styles.pressedButton],
+            children: /*#__PURE__*/_jsx(Text, {
+              style: styles.copyButtonText,
+              children: copied ? 'Copied' : 'Copy session ID'
+            })
+          }), /*#__PURE__*/_jsx(SessionDetail, {
+            label: "App",
+            value: appName
+          }), /*#__PURE__*/_jsx(SessionDetail, {
+            label: "App ID",
+            value: appId ?? 'Not available',
+            selectable: true
+          }), /*#__PURE__*/_jsx(SessionDetail, {
+            label: "Environment ID",
+            value: environmentId ?? 'Not available',
+            selectable: true
+          }), /*#__PURE__*/_jsx(SessionDetail, {
+            label: "Region",
+            value: region
+          }), /*#__PURE__*/_jsx(SessionDetail, {
+            label: "App version",
+            value: appVersion ?? 'Not available'
+          }), /*#__PURE__*/_jsx(Pressable, {
+            accessibilityRole: "button",
+            onPress: close,
+            style: styles.closeButton,
+            children: /*#__PURE__*/_jsx(Text, {
+              style: styles.closeButtonText,
+              children: "Close"
+            })
+          })]
+        })
+      })
+    })]
+  });
+}
+function SessionDetail({
+  label,
+  value,
+  selectable = false,
+  singleLine = false
+}) {
+  return /*#__PURE__*/_jsxs(View, {
+    style: styles.row,
+    children: [/*#__PURE__*/_jsx(Text, {
+      style: styles.label,
+      children: label
+    }), /*#__PURE__*/_jsx(Text, {
+      adjustsFontSizeToFit: singleLine,
+      minimumFontScale: 0.85,
+      numberOfLines: singleLine ? 1 : undefined,
+      selectable: selectable,
+      style: styles.value,
+      children: value
+    })]
+  });
+}
+const styles = StyleSheet.create({
+  content: {
+    flex: 1
+  },
+  backdrop: {
+    alignItems: 'center',
+    backgroundColor: 'rgba(0, 0, 0, 0.48)',
+    flex: 1,
+    justifyContent: 'center',
+    paddingHorizontal: 12,
+    paddingVertical: 24
+  },
+  panel: {
+    backgroundColor: '#FFFFFF',
+    borderRadius: 8,
+    maxWidth: 520,
+    paddingHorizontal: 16,
+    paddingVertical: 24,
+    width: '100%'
+  },
+  title: {
+    color: '#242424',
+    fontSize: 20,
+    fontWeight: '700',
+    marginBottom: 20
+  },
+  row: {
+    marginBottom: 14
+  },
+  label: {
+    color: '#616161',
+    fontSize: 12,
+    fontWeight: '600',
+    marginBottom: 3
+  },
+  value: {
+    color: '#242424',
+    fontSize: 15,
+    lineHeight: 21
+  },
+  copyButton: {
+    alignSelf: 'flex-start',
+    borderColor: '#0F6CBD',
+    borderRadius: 4,
+    borderWidth: 1,
+    marginBottom: 14,
+    marginTop: -4,
+    paddingHorizontal: 12,
+    paddingVertical: 7
+  },
+  copyButtonText: {
+    color: '#0F6CBD',
+    fontSize: 13,
+    fontWeight: '600'
+  },
+  disabledButton: {
+    opacity: 0.45
+  },
+  pressedButton: {
+    opacity: 0.7
+  },
+  closeButton: {
+    alignItems: 'center',
+    alignSelf: 'flex-end',
+    backgroundColor: '#0F6CBD',
+    borderRadius: 4,
+    marginTop: 8,
+    minWidth: 88,
+    paddingHorizontal: 18,
+    paddingVertical: 10
+  },
+  closeButtonText: {
+    color: '#FFFFFF',
+    fontSize: 14,
+    fontWeight: '600'
+  }
+});

package/lib/module/telemetry/OfflineSdkTelemetry.js

@@ -0,0 +1,91 @@
+"use strict";
+
+import { getAppLogger } from '@microsoft/power-apps-native-common';
+import * as OfflineSdk from '@microsoft/power-apps-native-offline';
+
+/**
+ * Operation names for this adapter's own diagnostics, following the
+ * `PowerAppsHost.<Subsystem>.<Action>` convention used by `HostOperationNames`.
+ *
+ * Declared locally rather than imported from `./index`: this module must stay
+ * fail-open and side-effect free, and the barrel constructs HTTP clients at
+ * import time. Two string constants are not worth that dependency.
+ */
+const OfflineTelemetryBindFailed = 'PowerAppsHost.Offline.TelemetryBind.Failed';
+const OfflineTelemetryUnbindFailed = 'PowerAppsHost.Offline.TelemetryUnbind.Failed';
+
+/**
+ * Non-sensitive error discriminator. Records the error's constructor name only,
+ * never its message, so diagnostics cannot leak user or tenant data.
+ */
+function getSafeErrorName(error) {
+  return error instanceof Error ? error.constructor.name : typeof error;
+}
+
+/**
+ * True when the resolved SDK exposes the v1 host-telemetry transport.
+ *
+ * Reading a missing export yields `undefined` rather than throwing, so this
+ * probe is safe on SDK builds that predate the transport. Keeping it separate
+ * from the `try`/`catch` below is what lets an out-of-range SDK stay a silent,
+ * expected no-op while genuine wiring failures still get reported.
+ *
+ * The version equality matters as much as the `typeof`: a future transport
+ * revision with a different sink shape would accept a v1 sink and silently
+ * malform every event rather than throw.
+ */
+function isTransportSupported() {
+  return typeof OfflineSdk.configureOfflineHostTelemetry === 'function' && OfflineSdk.OFFLINE_HOST_TELEMETRY_TRANSPORT_VERSION === 1;
+}
+
+/**
+ * Forwards the privacy-safe Offline SDK transport through the host's existing
+ * app logger so offline events carry the same session, device, and user data.
+ *
+ * The host owns exactly one thing here: binding the SDK transport to this
+ * host's logger. Buffering and teardown semantics live in the SDK.
+ *
+ * Setup and teardown are fail-open but not silent. This runs from an effect in
+ * the provider that roots the app, so an unguarded throw would take down the
+ * whole tree — telemetry is never worth an app that will not start. An
+ * unexpected failure is therefore downgraded to a logged diagnostic rather than
+ * swallowed, so broken wiring stays observable.
+ */
+export function configureOfflineSdkTelemetry(forwardEvents) {
+  if (!isTransportSupported()) {
+    return () => undefined;
+  }
+  const stopForwarding = () => {
+    try {
+      OfflineSdk.configureOfflineHostTelemetry(undefined);
+    } catch (e) {
+      getAppLogger().trackErrorEvent(OfflineTelemetryUnbindFailed, {
+        errorName: getSafeErrorName(e)
+      });
+    }
+  };
+  if (!forwardEvents) {
+    stopForwarding();
+    return stopForwarding;
+  }
+  try {
+    OfflineSdk.configureOfflineHostTelemetry({
+      // Resolved per event, not captured: the Dev Player swaps the logger when
+      // it switches apps, and a captured instance would strand events.
+      //
+      // `name` is the operation name only. Deliberately not passed as the
+      // optional third `eventName` argument: that overrides the canonical
+      // `PowerAppsClient.Activity`/`.Error` 1DS event names, which would hide
+      // every offline event from the queries and dashboards that filter on
+      // them. The name already reaches 1DS as `operation_Name`.
+      trackActivityEvent: (name, properties) => getAppLogger().trackActivityEvent(name, properties),
+      trackErrorEvent: (name, properties) => getAppLogger().trackErrorEvent(name, properties)
+    });
+  } catch (e) {
+    getAppLogger().trackErrorEvent(OfflineTelemetryBindFailed, {
+      errorName: getSafeErrorName(e)
+    });
+    return () => undefined;
+  }
+  return stopForwarding;
+}

package/lib/module/telemetry/OfflineSdkTelemetry.web.js

@@ -0,0 +1,5 @@
+"use strict";
+
+export function configureOfflineSdkTelemetry(_forwardEvents) {
+  return () => undefined;
+}

package/lib/module/telemetry/index.js

@@ -10,8 +10,9 @@
  * alongside the canonical host operation-name constants.
  */
 
-export { getAppLogger, configureAppLogger } from '@microsoft/power-apps-native-common';
-
+import { HttpClient } from '@microsoft/power-apps-native-common/http';
+import { isDebugLoggingEnabled } from "../logger.js";
+export { getAppLogger, configureAppLogger, getCustomerTelemetryLogger } from '@microsoft/power-apps-native-common';
 /**
  * Canonical operation names for host package telemetry.
  * Follow the `PowerAppsHost.<Subsystem>.<Action>` convention so events are
@@ -42,14 +43,24 @@ export const HostOperationNames = {
   /** Top-level React error boundary caught an unhandled JS error. */
   RuntimeUnhandledJsError: 'PowerAppsHost.Runtime.UnhandledJsError',
   // ── Platform APIs ─────────────────────────────────────────────────────────
+  /** Power Platform RP HTTP request, including backend correlation IDs. */
+  PlatformHttpRequest: 'PowerAppsHost.Platform.HttpRequest',
   /** Resolve Dataverse instanceUrl from Power Platform environment API. */
   PlatformFetchInstanceUrl: 'PowerAppsHost.Platform.FetchInstanceUrl',
   /** useConnectionRefs failed to resolve connections (recoverable). Recorded only on failure. */
   PlatformLoadConnectionsFailed: 'PowerAppsHost.Platform.LoadConnections.Failed',
   /** Create a new Power Platform connection. */
   PlatformCreateConnection: 'PowerAppsHost.Platform.CreateConnection',
+  /** Repair an existing Power Platform connection. */
+  PlatformRepairConnection: 'PowerAppsHost.Platform.RepairConnection',
+  /** Poll a connection until it becomes active. */
+  PlatformPollConnectionStatus: 'PowerAppsHost.Platform.PollConnectionStatus',
   /** Resolve app connection references for the current launch. */
   PlatformResolveConnectionRefs: 'PowerAppsHost.Platform.ResolveConnectionRefs',
   /** Grant this app access to a Power Platform connection ACL. */
-  PlatformConnectionAclGrant: 'PowerAppsHost.Platform.ConnectionAclGrant'
-};
+  PlatformConnectionAclGrant: 'PowerAppsHost.Platform.ConnectionAclGrant',
+  /** Installed Offline SDK predates the SDK-owned routing contract. */
+  OfflineRoutingContractUnsupported: 'PowerAppsHost.Offline.RoutingContract.Unsupported'
+};
+export const bridgeHttpClient = new HttpClient(HostOperationNames.BridgeHttpRequest, isDebugLoggingEnabled);
+export const platformHttpClient = new HttpClient(HostOperationNames.PlatformHttpRequest, isDebugLoggingEnabled);

package/lib/typescript/commonjs/auth/AuthContext.d.ts

@@ -46,9 +46,11 @@ export interface AuthProviderProps {
      * Pass explicitly only to override the default (e.g. in tests).
      */
     intuneConfig?: IntuneConfig;
+    /** Token audiences that must be available before the account is considered signed in. */
+    requiredScopes?: string[];
     children: React.ReactNode;
 }
-export declare function AuthProvider({ msalConfig, intuneConfig, children }: AuthProviderProps): React.JSX.Element;
+export declare function AuthProvider({ msalConfig, intuneConfig, requiredScopes, children, }: AuthProviderProps): React.JSX.Element;
 /**
  * Returns the current auth state from the nearest <AuthProvider>.
  * Must be called within the AuthProvider tree.

package/lib/typescript/commonjs/auth/AuthContext.web.d.ts

@@ -0,0 +1,21 @@
+import React from 'react';
+import type { IntuneConfig, MsalAuthConfig } from '@microsoft/power-apps-native-auth';
+export interface AuthState {
+    isLoading: boolean;
+    isAuthReady: boolean;
+    isSignedIn: boolean;
+    hasRealAccount: boolean;
+    error: Error | null;
+    acquireToken: (scopes: string[]) => Promise<string | null>;
+    signIn: () => Promise<void>;
+    signOut: () => Promise<void>;
+}
+export interface AuthProviderProps {
+    msalConfig: MsalAuthConfig;
+    intuneConfig?: IntuneConfig;
+    requiredScopes?: string[];
+    children: React.ReactNode;
+}
+export declare function AuthProvider({ children }: AuthProviderProps): React.JSX.Element;
+export declare function useAuth(): AuthState;
+//# sourceMappingURL=AuthContext.web.d.ts.map

package/lib/typescript/commonjs/auth/completePowerAppsAuthSession.d.ts

@@ -0,0 +1,8 @@
+import type { WebBrowserCompleteAuthSessionOptions, WebBrowserCompleteAuthSessionResult } from 'expo-web-browser';
+/**
+ * Completes an Expo web authentication popup when the current route is its
+ * redirect target. Call this at module initialization in the OAuth callback
+ * route; navigation after completion remains application-owned.
+ */
+export declare function completePowerAppsAuthSession(options?: WebBrowserCompleteAuthSessionOptions): WebBrowserCompleteAuthSessionResult;
+//# sourceMappingURL=completePowerAppsAuthSession.d.ts.map

package/lib/typescript/commonjs/bridge/PowerPagesBridge.d.ts

@@ -0,0 +1,18 @@
+import type { AppConnectionReference, CdsDataSourceConfig } from './NativePowerAppsBridge';
+export type PowerPagesBridgeOptions = {
+    dataSources: CdsDataSourceConfig[];
+    connections: Record<string, AppConnectionReference>;
+};
+export declare class PowerPagesBridge {
+    private options;
+    constructor(options: PowerPagesBridgeOptions);
+    updateOptions(options: PowerPagesBridgeOptions): void;
+    initialize(): Promise<void>;
+    createRequestBody(config: {
+        body?: string | Uint8Array | ArrayBuffer | Blob;
+    }): Blob | string | Uint8Array | ArrayBuffer;
+    executePluginAsync<T = unknown>(pluginName: string, pluginAction: string, params: unknown[]): Promise<T>;
+    private sendHttpAsync;
+}
+export declare function setupPowerPagesHost(options: PowerPagesBridgeOptions): void;
+//# sourceMappingURL=PowerPagesBridge.d.ts.map

package/lib/typescript/commonjs/bridge/bridgeState.d.ts

@@ -0,0 +1,5 @@
+import type { NativeBridgeOptions } from './NativePowerAppsBridge';
+export declare function getRequestBodyForMethod(method: string, body: BodyInit | null): BodyInit | null;
+export declare function assertSuccessfulHttpStatus(status: number, method: string): void;
+export declare function updateBridgeOptionsInPlace(current: NativeBridgeOptions, next: NativeBridgeOptions): NativeBridgeOptions;
+//# sourceMappingURL=bridgeState.d.ts.map

package/lib/typescript/commonjs/connections/ConnectionSetupScreen.d.ts

@@ -39,12 +39,23 @@
  * the consuming app decides how to render it (full-screen, modal, etc.).
  */
 import React from 'react';
-import type { ConnectorSchema } from '../platform/useConnectionRefs';
+import type { ConnectionConsentDetails, ResourceConsentRequirement } from '../connections/types';
+import type { ConnectorSchema } from './useConnectionRefs';
 export interface MissingConnectorEntry {
     /** Connector API ID (e.g. "/providers/Microsoft.PowerApps/apis/shared_office365users"). */
     apiId: string;
     /** Local ref ID from power.config.json (for correlation). */
     localRefId: string;
+    /** Canonical connector short name. Supplied by useConnectionRefs. */
+    connectorId?: string;
+    dataSources?: string[];
+    displayName?: string;
+    iconUri?: string;
+    appActions?: string[];
+    gatewayObjectIdHint?: string;
+    authenticationType?: string;
+    parameterSetName?: string;
+    sharedConnectionId?: string;
 }
 export interface ConnectionSetupScreenProps {
     /**
@@ -60,11 +71,20 @@ export interface ConnectionSetupScreenProps {
     environmentId: string;
     region?: string;
     acquireToken: (scopes: string[]) => Promise<string | null>;
+    onSignOut?: () => void | Promise<void>;
     /**
      * Called when all missing connections have been resolved.
-     * `resolvedIds` maps apiId → connectionId for all newly created connections.
+    * `resolvedIds` maps localRefId → connectionId for all newly created connections.
      */
-    onAllConnected: (resolvedIds: Record<string, string>) => void;
+    onAllConnected: (resolvedIds: Record<string, string>) => void | Promise<void>;
+    /** All connector usages requiring user approval, including already-resolved references. */
+    consentDetails?: ConnectionConsentDetails[];
+    /** Additional protected resources, such as cross-environment Dataverse instances. */
+    resourceConsents?: ResourceConsentRequirement[];
+    /** Called when the user explicitly declines access. */
+    onConsentDeclined?: () => void | Promise<void>;
+    /** Whether to show app-level Review Access after authentication. Defaults to true. */
+    showReview?: boolean;
     /**
      * If provided, a "Skip" button is shown. Useful for non-blocking connection flows.
      * The app should handle the case where connections remain unresolved.
@@ -76,11 +96,12 @@ export interface ConnectionSetupScreenProps {
      * access on each newly created connection, fixing the APIM 403 for
      * third-party app tokens.
      */
-    isvClientId?: string;
+    isvClientId: string;
     /**
      * Optional custom renderer for the OAuth WebView.
      * Receives the consent URL and a dismiss callback.
-     * If not provided, `Linking.openURL()` is used to open the URL in the system browser.
+    * If not provided, Expo's system authentication browser is used.
+    * Custom views should pass their final redirect URL to `onDone` when available.
      *
      * @example
      *   // Using react-native-webview:
@@ -91,7 +112,7 @@ export interface ConnectionSetupScreenProps {
      *     </Modal>
      *   )}
      */
-    renderOAuthWebView?: (url: string, onDone: () => void) => React.ReactNode;
+    renderOAuthWebView?: (url: string, onDone: (redirectUrl?: string) => void) => React.ReactNode;
     /** Optional title override (default: "Set up connections"). */
     title?: string;
 }
@@ -103,5 +124,5 @@ export interface ConnectionSetupScreenProps {
  * resolved `onAllConnected` fires and the parent app should unmount this
  * component and proceed to launch the app.
  */
-export declare function ConnectionSetupScreen({ missingConnectors, schemaMap, environmentId, region, acquireToken, isvClientId, onAllConnected, onSkip, renderOAuthWebView, title, }: ConnectionSetupScreenProps): React.JSX.Element;
+export declare function ConnectionSetupScreen({ missingConnectors, schemaMap, environmentId, region, acquireToken, onSignOut, isvClientId, onAllConnected, onSkip, consentDetails, resourceConsents, onConsentDeclined, showReview, renderOAuthWebView, title, }: ConnectionSetupScreenProps): React.JSX.Element;
 //# sourceMappingURL=ConnectionSetupScreen.d.ts.map