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

package/lib/commonjs/auth/AuthContext.js

@@ -36,6 +36,32 @@ const SIGN_IN_SCOPES = ['https://api.powerplatform.com/.default'];
 function getSafeErrorName(error) {
   return error instanceof Error ? error.constructor.name : typeof error;
 }
+function getErrorProperty(error, propertyName) {
+  return error && typeof error === 'object' ? error[propertyName] : undefined;
+}
+function getSafeErrorMessage(error) {
+  if (error instanceof Error) return error.message;
+  return typeof error === 'string' ? error : String(error);
+}
+function getAuthErrorTelemetry(error) {
+  const errorMessage = getSafeErrorMessage(error);
+  const parsedNSError = /domain=([^\s]+) code=(-?\d+)/.exec(errorMessage);
+  return {
+    errorName: getSafeErrorName(error),
+    errorCode: getErrorProperty(error, 'code'),
+    nativeErrorDomain: getErrorProperty(error, 'nativeErrorDomain') ?? parsedNSError?.[1],
+    nativeErrorCode: getErrorProperty(error, 'nativeErrorCode') ?? parsedNSError?.[2],
+    nativeErrorMessage: errorMessage.slice(0, 512)
+  };
+}
+function getAuthTelemetryProperties(useBroker, useEmbeddedWebView) {
+  return {
+    authMode: useBroker ? 'wrap' : 'nonWrap',
+    platform: _reactNative.Platform.OS,
+    useBroker,
+    useEmbeddedWebView
+  };
+}
 function accountsMatch(left, right) {
   return left.identifier === right.identifier && left.tenantId === right.tenantId;
 }
@@ -166,10 +192,8 @@ function AuthProvider({
       } : {})
     });
     pcaRef.current = pca;
-    const authInitScenario = (0, _index.getAppLogger)().trackScenario(_index.HostOperationNames.AuthInit, {
-      useBroker,
-      platform: _reactNative.Platform.OS
-    });
+    const authTelemetryProperties = getAuthTelemetryProperties(useBroker, useEmbeddedWebView);
+    const authInitScenario = (0, _index.getAppLogger)().trackScenario(_index.HostOperationNames.AuthInit, authTelemetryProperties);
     pca.init().then(() => pca.getAccounts()).then(async accounts => {
       let restoredAccount = accounts[0] ?? null;
       if (restoredAccount) {
@@ -201,9 +225,7 @@ function AuthProvider({
       setError(e instanceof Error ? e : new Error(String(e)));
       setIsAuthReady(true);
       setIsLoading(false);
-      authInitScenario.fail(undefined, {
-        errorName: getSafeErrorName(e)
-      });
+      authInitScenario.fail(undefined, getAuthErrorTelemetry(e));
     });
     // Re-initialize only when the effective broker/identity settings change.
     // eslint-disable-next-line react-hooks/exhaustive-deps
@@ -213,9 +235,8 @@ function AuthProvider({
     if (!pca) return;
     setIsLoading(true);
     setError(null);
-    const signInScenario = (0, _index.getAppLogger)().trackScenario(_index.HostOperationNames.AuthSignIn, {
-      useBroker
-    });
+    const authTelemetryProperties = getAuthTelemetryProperties(useBroker, useEmbeddedWebView);
+    const signInScenario = (0, _index.getAppLogger)().trackScenario(_index.HostOperationNames.AuthSignIn, authTelemetryProperties);
     try {
       // If init() failed on mount, retry it now before attempting sign-in.
       if (!pca.isInitialized) {
@@ -244,16 +265,15 @@ function AuthProvider({
           // Intune Conditional Access on the next token acquisition.
           (0, _logger.debugWarn)('[AuthProvider] Intune enrollment failed:', intuneErr);
           (0, _index.getAppLogger)().trackErrorEvent(_index.HostOperationNames.AuthIntuneEnroll, {
-            errorName: getSafeErrorName(intuneErr)
+            ...authTelemetryProperties,
+            ...getAuthErrorTelemetry(intuneErr)
           });
         }
       }
       signInScenario.complete();
     } catch (e) {
       setError(e instanceof Error ? e : new Error(String(e)));
-      signInScenario.fail(undefined, {
-        errorName: getSafeErrorName(e)
-      });
+      signInScenario.fail(undefined, getAuthErrorTelemetry(e));
     } finally {
       setIsLoading(false);
     }
@@ -270,8 +290,9 @@ function AuthProvider({
     } catch (e) {
       (0, _logger.debugWarn)('[AuthContext] acquireTokenSilent failed for scopes:', scopes, e);
       (0, _index.getAppLogger)().trackErrorEvent(_index.HostOperationNames.AuthAcquireTokenSilentFailed, {
+        ...getAuthTelemetryProperties(useBroker, useEmbeddedWebView),
         scopeCount: scopes.length,
-        errorName: getSafeErrorName(e)
+        ...getAuthErrorTelemetry(e)
       });
       if (scopes.some(scope => effectiveRequiredScopes.includes(scope))) {
         await pca.signOut({

package/lib/commonjs/config/babelConfig.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createPowerAppsBabelConfig = createPowerAppsBabelConfig;
+function createPowerAppsBabelConfig(api, options = {}) {
+  api.cache(true);
+  return {
+    presets: ['babel-preset-expo', ...(options.presets || [])],
+    plugins: [...(options.plugins || []), 'react-native-reanimated/plugin']
+  };
+}

package/lib/commonjs/config/expoConfig.js

@@ -0,0 +1,71 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createPowerAppsExpoConfig = createPowerAppsExpoConfig;
+/**
+ * Branding placeholder used when the app supplies no icon/splash of its own.
+ *
+ * Expo only carves out native branding slots for images it knows about at
+ * prebuild time. Passing nothing means no slot is generated, and the wrap
+ * pipeline then has nothing to overwrite — so customer icons and splash
+ * screens silently never appear in the wrapped app. Always supplying a source
+ * guarantees the slots exist and are replaceable:
+ *   Android — res/mipmap-*\/ic_launcher*.png, res/drawable-*\/splashscreen_logo.png
+ *   iOS     — AppIcon and SplashScreenLogo imagesets
+ */
+const PLACEHOLDER_BRANDING_IMAGE = './assets/adaptive-icon.png';
+function createPowerAppsExpoConfig(baseConfig, settings, customize = config => config) {
+  const resolvedIconPath = settings.iconPath || PLACEHOLDER_BRANDING_IMAGE;
+  const resolvedSplashPath = settings.splashPath || process.env.APP_SPLASH_PATH || PLACEHOLDER_BRANDING_IMAGE;
+  const icon = {
+    icon: resolvedIconPath
+  };
+  const adaptiveIcon = {
+    adaptiveIcon: {
+      foregroundImage: resolvedIconPath,
+      backgroundColor: '#ffffff'
+    }
+  };
+  return customize({
+    ...baseConfig,
+    ...icon,
+    name: settings.name,
+    slug: settings.slug,
+    version: settings.version,
+    scheme: settings.scheme,
+    userInterfaceStyle: 'automatic',
+    web: {
+      bundler: 'metro',
+      output: 'static'
+    },
+    platforms: ['ios', 'android', 'web'],
+    experiments: {
+      typedRoutes: true
+    },
+    plugins: [...(settings.isDevClient ? ['expo-dev-client'] : []), 'expo-asset', 'expo-audio', 'expo-font', 'expo-image', 'expo-mail-composer', 'expo-router', 'expo-secure-store', 'expo-sharing', 'expo-video', 'expo-web-browser', '@microsoft/power-apps-native-host', '@microsoft/power-apps-native-offline', '@react-native-community/datetimepicker',
+    // Configured explicitly rather than left to Expo's default so prebuild
+    // emits named, resource-table-registered splash assets the wrap pipeline
+    // can overwrite: res/drawable-*/splashscreen_logo.png on Android and the
+    // SplashScreenLogo imageset on iOS.
+    ['expo-splash-screen', {
+      image: resolvedSplashPath,
+      imageWidth: 200,
+      resizeMode: 'contain',
+      backgroundColor: '#ffffff'
+    }]],
+    android: {
+      package: settings.androidPackage,
+      versionCode: settings.versionCode,
+      ...adaptiveIcon
+    },
+    ios: {
+      supportsTablet: true,
+      bundleIdentifier: settings.iosBundleIdentifier,
+      infoPlist: {
+        LSApplicationQueriesSchemes: ['intunemam', 'ms-acompli', 'msauthv2', 'msauthv3']
+      }
+    }
+  });
+}

package/lib/commonjs/config/metroConfig.js

@@ -0,0 +1,70 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createPowerAppsMetroConfig = createPowerAppsMetroConfig;
+var _nodePath = _interopRequireDefault(require("node:path"));
+var _nodeModule = require("node:module");
+var _nodeFs = _interopRequireDefault(require("node:fs"));
+var _metroConfig = require("expo/metro-config.js");
+var _metroLogger = require("./metroLogger.js");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function nativeRuntimeVersions(projectRoot) {
+  const appConfig = JSON.parse(_nodeFs.default.readFileSync(_nodePath.default.join(projectRoot, 'app.json'), 'utf8'));
+  const versions = appConfig.expo?.extra?.powerappsNative?.nativeRuntimeVersions;
+  if (!Number.isInteger(versions?.android) || versions.android < 1 || !Number.isInteger(versions?.ios) || versions.ios < 1) {
+    throw new Error('app.json is missing valid expo.extra.powerappsNative.nativeRuntimeVersions');
+  }
+  return versions;
+}
+function templateVersion(projectRoot) {
+  const appConfig = JSON.parse(_nodeFs.default.readFileSync(_nodePath.default.join(projectRoot, 'app.json'), 'utf8'));
+  const version = appConfig.expo?.extra?.powerappsNative?.templateVersion;
+  if (!Number.isInteger(version) || version < 1) {
+    throw new Error('app.json is missing a valid expo.extra.powerappsNative.templateVersion');
+  }
+  return version;
+}
+function createPowerAppsMetroConfig(projectRoot, customize = config => config) {
+  const projectRequire = (0, _nodeModule.createRequire)(_nodePath.default.join(projectRoot, 'package.json'));
+  const config = (0, _metroConfig.getDefaultConfig)(projectRoot);
+  config.resolver.sourceExts = [...config.resolver.sourceExts, 'mjs'];
+  config.server = {
+    ...config.server,
+    enhanceMiddleware: middleware => (0, _metroLogger.withPowerNativeMetroLogging)((request, response, next) => {
+      if (request.url === '/__pawrap_verify') {
+        response.setHeader('Content-Type', 'application/json');
+        response.setHeader('Access-Control-Allow-Origin', '*');
+        response.end(JSON.stringify({
+          type: 'pawrap-app',
+          version: '1',
+          templateVersion: templateVersion(projectRoot),
+          nativeRuntimeVersions: nativeRuntimeVersions(projectRoot)
+        }));
+        return;
+      }
+      middleware(request, response, next);
+    }, {
+      projectRoot
+    })
+  };
+  const defaultResolver = config.resolver.resolveRequest;
+  const resolveRequest = (context, moduleName, platform) => {
+    const isNodeRenderer = context.customResolverOptions?.environment === 'node';
+    if (!isNodeRenderer && (moduleName === 'react' || moduleName.startsWith('react/')) || moduleName === 'react-native' && platform !== 'web' || moduleName.startsWith('@babel/runtime')) {
+      return {
+        filePath: projectRequire.resolve(moduleName, {
+          paths: [_nodePath.default.resolve(projectRoot, 'node_modules')]
+        }),
+        type: 'sourceFile'
+      };
+    }
+    return defaultResolver ? defaultResolver(context, moduleName, platform) : context.resolveRequest(context, moduleName, platform);
+  };
+  config.resolver = {
+    ...config.resolver,
+    resolveRequest
+  };
+  return customize(config);
+}

package/lib/commonjs/config/metroLogger.js

@@ -0,0 +1,182 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.enablePowerNativeMetroLogging = enablePowerNativeMetroLogging;
+exports.redactMetroLog = redactMetroLog;
+exports.withPowerNativeMetroLogging = withPowerNativeMetroLogging;
+var _nodeFs = _interopRequireDefault(require("node:fs"));
+var _nodePath = _interopRequireDefault(require("node:path"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const SENSITIVE_LINE_PATTERN = /\b(?:authorization|bearer|client[_-]?secret|password|token|access[_-]?token|refresh[_-]?token|id[_-]?token|api[_-]?key|accountkey|sharedaccesskey)\b|[?&](?:sig|se|sp|sv|token|access_token|code|client_secret)=|\b(?:AKIA[0-9A-Z]{16}|ghp_[A-Za-z0-9]{30,}|sk-[A-Za-z0-9]{20,})\b/i;
+const DEFAULT_MAX_ERROR_BODY_BYTES = 256 * 1024;
+const stateByRoot = new Map();
+function stripAnsi(value) {
+  return String(value).replace(/[\u001B\u009B][[\]()#;?]*(?:(?:(?:[a-zA-Z\d]*(?:;[-a-zA-Z\d\/#&.:=?%@~_]+)*)?\u0007)|(?:(?:\d{1,4}(?:[;:]\d{0,4})*)?[\dA-PR-TZcf-nq-uy=><~]))/g, '');
+}
+function redactMetroLog(value) {
+  return stripAnsi(value).replace(/[^\r\n]*(?:\r\n|\r|\n)|[^\r\n]+$/g, line => {
+    if (!SENSITIVE_LINE_PATTERN.test(line)) return line;
+    const ending = line.endsWith('\r\n') ? '\r\n' : line.endsWith('\n') ? '\n' : line.endsWith('\r') ? '\r' : '';
+    return `[powernative] [REDACTED_SENSITIVE_LINE]${ending}`;
+  });
+}
+function toError(value) {
+  return value instanceof Error ? value : new Error(String(value));
+}
+function writeDiagnostic(state, message) {
+  try {
+    state.diagnosticWrite(message);
+  } catch (error) {
+    state.diagnosticWriteError = toError(error);
+  }
+}
+function reportInstrumentationError(state, error, phase) {
+  if (state.instrumentationError) return;
+  const normalizedError = toError(error);
+  const context = {
+    phase,
+    logPath: state.logPath
+  };
+  state.instrumentationError = {
+    error: normalizedError,
+    context
+  };
+  if (state.onError) {
+    try {
+      state.onError(normalizedError, context);
+      return;
+    } catch (callbackError) {
+      state.onErrorFailure = toError(callbackError);
+      writeDiagnostic(state, `[powernative] Metro logging instrumentation failed during ${phase}: ${normalizedError.message}; onError callback also failed: ${state.onErrorFailure.message}\n`);
+      return;
+    }
+  }
+  writeDiagnostic(state, `[powernative] Metro logging instrumentation failed during ${phase}: ${normalizedError.message}\n`);
+}
+function createMetroLogState(projectRoot, onError) {
+  const root = _nodePath.default.resolve(projectRoot || process.cwd());
+  const logDir = _nodePath.default.join(root, '.powernative', 'metro-logs');
+  const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const patchedWrite = process.stderr.write;
+  const stderrWrite = patchedWrite.__powerNativeMetroLoggerOriginal || patchedWrite;
+  const state = {
+    root,
+    logDir,
+    stamp,
+    port: 'unknown',
+    logPath: _nodePath.default.join(logDir, `metro-${stamp}-pid-${process.pid}-port-unknown.log`),
+    onError: onError || null,
+    instrumentationError: null,
+    diagnosticWrite: message => Reflect.apply(stderrWrite, process.stderr, [message])
+  };
+  stateByRoot.set(root, state);
+  return state;
+}
+function getMetroLogState(projectRoot, onError) {
+  const root = _nodePath.default.resolve(projectRoot || process.cwd());
+  const state = stateByRoot.get(root) || createMetroLogState(root, onError);
+  if (onError) state.onError = onError;
+  return state;
+}
+function appendMetroLog(state, value) {
+  try {
+    _nodeFs.default.mkdirSync(state.logDir, {
+      recursive: true
+    });
+    _nodeFs.default.appendFileSync(state.logPath, redactMetroLog(value));
+  } catch (error) {
+    reportInstrumentationError(state, error, 'log persistence');
+  }
+}
+function setMetroLogPort(state, port) {
+  if (!Number.isInteger(port) || port <= 0 || String(port) === state.port) return;
+  const previousPath = state.logPath;
+  state.port = String(port);
+  state.logPath = _nodePath.default.join(state.logDir, `metro-${state.stamp}-pid-${process.pid}-port-${state.port}.log`);
+  try {
+    _nodeFs.default.mkdirSync(state.logDir, {
+      recursive: true
+    });
+    if (_nodeFs.default.existsSync(previousPath) && previousPath !== state.logPath) {
+      _nodeFs.default.renameSync(previousPath, state.logPath);
+    }
+  } catch (error) {
+    state.logPath = previousPath;
+    reportInstrumentationError(state, error, 'port-tagged log rename');
+  }
+}
+function extractMetroPort(value) {
+  const match = String(value).match(/(?:localhost|127\.0\.0\.1|0\.0\.0\.0|\[::1\]):(\d{2,5})/);
+  const port = match ? Number(match[1]) : null;
+  return Number.isInteger(port) && Number(port) > 0 && Number(port) <= 65535 ? port : null;
+}
+function patchStream(stream, key, state) {
+  const originalWrite = stream.write;
+  if (originalWrite.__powerNativeMetroLoggerPatched) return;
+  const patchedWrite = function (chunk, ...args) {
+    try {
+      const text = Buffer.isBuffer(chunk) ? chunk.toString('utf8') : String(chunk);
+      appendMetroLog(state, text);
+      const port = extractMetroPort(text);
+      if (port) setMetroLogPort(state, port);
+    } catch (error) {
+      reportInstrumentationError(state, error, `${key} capture`);
+    }
+    return Reflect.apply(originalWrite, stream, [chunk, ...args]);
+  };
+  patchedWrite.__powerNativeMetroLoggerPatched = true;
+  patchedWrite.__powerNativeMetroLoggerOriginal = originalWrite;
+  stream.write = patchedWrite;
+}
+function enablePowerNativeMetroLogging(options = {}) {
+  const state = getMetroLogState(options.projectRoot, options.onError);
+  try {
+    patchStream(process.stdout, 'stdout', state);
+    patchStream(process.stderr, 'stderr', state);
+    appendMetroLog(state, `[powernative] Metro log started pid=${process.pid}\n`);
+  } catch (error) {
+    reportInstrumentationError(state, error, 'stream setup');
+  }
+  return {
+    logDir: state.logDir,
+    logPath: state.logPath
+  };
+}
+function withPowerNativeMetroLogging(middleware, options = {}) {
+  const state = getMetroLogState(options.projectRoot, options.onError);
+  const maxBodyBytes = Number.isInteger(options.maxBodyBytes) && Number(options.maxBodyBytes) > 0 ? Number(options.maxBodyBytes) : DEFAULT_MAX_ERROR_BODY_BYTES;
+  enablePowerNativeMetroLogging(options);
+  return (request, response, next) => {
+    try {
+      setMetroLogPort(state, Number(request.socket.localPort));
+      const chunks = [];
+      let capturedBytes = 0;
+      const write = response.write.bind(response);
+      const end = response.end.bind(response);
+      function captureChunk(chunk, encoding) {
+        if (!chunk || capturedBytes >= maxBodyBytes) return;
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk), typeof encoding === 'string' ? encoding : undefined);
+        const remaining = maxBodyBytes - capturedBytes;
+        chunks.push(buffer.length > remaining ? buffer.subarray(0, remaining) : buffer);
+        capturedBytes += Math.min(buffer.length, remaining);
+      }
+      response.write = (chunk, ...args) => {
+        captureChunk(chunk, args[0]);
+        return Reflect.apply(write, response, [chunk, ...args]);
+      };
+      response.end = (chunk, ...args) => {
+        captureChunk(chunk, args[0]);
+        if (response.statusCode >= 400) {
+          const body = Buffer.concat(chunks).toString('utf8').slice(0, maxBodyBytes);
+          appendMetroLog(state, `\n[powernative] HTTP ${request.method} ${request.url} -> ${response.statusCode}\n${body}\n`);
+        }
+        return Reflect.apply(end, response, [chunk, ...args]);
+      };
+    } catch (error) {
+      reportInstrumentationError(state, error, 'HTTP middleware setup');
+    }
+    return middleware(request, response, next);
+  };
+}

package/lib/commonjs/config/tamaguiConfig.js

@@ -0,0 +1,98 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createPowerAppsTamaguiConfig = createPowerAppsTamaguiConfig;
+exports.withPowerAppsSemanticAliases = withPowerAppsSemanticAliases;
+var _core = require("@tamagui/core");
+var _v = require("@tamagui/config/v5");
+var _v5Rn = require("@tamagui/config/v5-rn");
+function parseColorChannels(color) {
+  const hexMatch = color.match(/^#([\da-f]{3}|[\da-f]{6})$/i);
+  if (hexMatch) {
+    const hex = hexMatch[1].length === 3 ? [...hexMatch[1]].map(value => `${value}${value}`).join('') : hexMatch[1];
+    return [0, 2, 4].map(offset => Number.parseInt(hex.slice(offset, offset + 2), 16) / 255);
+  }
+  const rgbMatch = color.match(/^rgba?\(\s*([\d.]+)\s*,\s*([\d.]+)\s*,\s*([\d.]+)(?:\s*,\s*([\d.]+))?\s*\)$/i);
+  if (rgbMatch) {
+    const values = rgbMatch.slice(1, 4).map(Number);
+    if (values.some(value => !Number.isFinite(value) || value < 0 || value > 255)) return null;
+    const alpha = rgbMatch[4] === undefined ? 1 : Number(rgbMatch[4]);
+    if (!Number.isFinite(alpha) || alpha !== 1) return null;
+    return values.map(value => value / 255);
+  }
+  const hslMatch = color.match(/^hsla?\(\s*([-\d.]+)\s*,\s*([\d.]+)%\s*,\s*([\d.]+)%(?:\s*,\s*([\d.]+))?\s*\)$/i);
+  if (!hslMatch) return null;
+  const hsl = hslMatch.slice(1, 4).map(Number);
+  if (hsl.some(value => !Number.isFinite(value))) return null;
+  const alpha = hslMatch[4] === undefined ? 1 : Number(hslMatch[4]);
+  if (!Number.isFinite(alpha) || alpha !== 1) return null;
+  const hue = (hsl[0] % 360 + 360) % 360;
+  const saturation = hsl[1] / 100;
+  const lightness = hsl[2] / 100;
+  if (saturation < 0 || saturation > 1 || lightness < 0 || lightness > 1) return null;
+  const chroma = (1 - Math.abs(2 * lightness - 1)) * saturation;
+  const intermediate = chroma * (1 - Math.abs(hue / 60 % 2 - 1));
+  const offset = lightness - chroma / 2;
+  const segment = Math.floor(hue / 60);
+  const rgb = [[chroma, intermediate, 0], [intermediate, chroma, 0], [0, chroma, intermediate], [0, intermediate, chroma], [intermediate, 0, chroma], [chroma, 0, intermediate]][segment];
+  return rgb.map(value => value + offset);
+}
+function readableForeground(background, fallback) {
+  if (!background) return fallback;
+  const channels = parseColorChannels(background);
+  if (!channels) return fallback;
+  const linearChannels = channels.map(value => value <= 0.04045 ? value / 12.92 : ((value + 0.055) / 1.055) ** 2.4);
+  const luminance = 0.2126 * linearChannels[0] + 0.7152 * linearChannels[1] + 0.0722 * linearChannels[2];
+  return luminance > 0.179 ? '#000000' : '#ffffff';
+}
+function withPowerAppsSemanticAliases(theme, brand = {}) {
+  return {
+    ...theme,
+    surface0: brand.bg ?? theme.background,
+    surface1: brand.surface ?? theme.color3,
+    surface2: theme.color4,
+    surface3: brand.border ?? theme.color5,
+    mediaSurface: theme.color4,
+    accentDeep: brand.primary ?? theme.blue11,
+    accentBase: brand.primary ?? theme.blue10,
+    accentSoft: brand.accent ?? theme.blue3,
+    accentOnAccent: brand.onPrimary ?? readableForeground(brand.primary ?? theme.blue10, theme.color1),
+    text0: brand.text ?? theme.color12,
+    text1: brand.textMuted ?? theme.color11,
+    text2: theme.color10,
+    text3: theme.color9,
+    statusComplete: brand.statusSuccess ?? theme.green11,
+    statusCompleteBg: theme.green3,
+    statusPending: brand.statusWarning ?? theme.yellow11,
+    statusPendingBg: theme.yellow3,
+    statusOverdue: brand.statusDanger ?? theme.red11,
+    statusOverdueBg: theme.red3,
+    statusInProgress: brand.statusInfo ?? theme.blue11,
+    statusInProgressBg: theme.blue3,
+    statusDraft: theme.color10,
+    statusDraftBg: theme.color3,
+    statusCancelled: theme.red11,
+    statusCancelledBg: theme.red3
+  };
+}
+const powerAppsTamaguiDefaults = {
+  ..._v.defaultConfig,
+  animations: _v5Rn.animations,
+  themes: {
+    ..._v.defaultConfig.themes,
+    light: withPowerAppsSemanticAliases(_v.defaultConfig.themes.light),
+    dark: withPowerAppsSemanticAliases(_v.defaultConfig.themes.dark)
+  },
+  fonts: {
+    ..._v.defaultConfig.fonts,
+    mono: _v.defaultConfig.fonts.body
+  }
+};
+function createPowerAppsTamaguiConfig(overrides = {}) {
+  return (0, _core.createTamagui)({
+    ...powerAppsTamaguiDefaults,
+    ...overrides
+  });
+}

package/lib/commonjs/connections/resolveConnections.js

@@ -62,6 +62,7 @@ const API_VERSION = '1';
  */
 async function resolveViaStaticRefs({
   connectionReferences,
+  hasDataverse,
   schemaMap,
   environmentId,
   region,
@@ -99,8 +100,8 @@ async function resolveViaStaticRefs({
     Authorization: `Bearer ${token}`
   };
 
-  // Fetch Dataverse instanceUrl and all connection instances in parallel.
-  const [instanceUrl, ...connResults] = await Promise.all([(0, _DataverseGlobalDiscoveryApi.fetchInstanceUrl)(environmentId, region, acquireToken, token), ...Object.entries(directConnectionReferences).map(async ([localRefId, ref]) => {
+  // Fetch the Dataverse instanceUrl only when the app uses Dataverse.
+  const [instanceUrl, ...connResults] = await Promise.all([hasDataverse ? (0, _DataverseGlobalDiscoveryApi.fetchInstanceUrl)(environmentId, region, acquireToken, token) : Promise.resolve(undefined), ...Object.entries(directConnectionReferences).map(async ([localRefId, ref]) => {
     const apiId = (0, _types.normalizeApiId)(ref.id);
     const schema = schemaByApiId[apiId];
     if (!schema) {

package/lib/commonjs/connections/useConnectionRefs.js

@@ -67,6 +67,7 @@ function useConnectionRefs({
   environmentId,
   region = 'prod',
   connectionReferences,
+  hasDataverse,
   schemaMap,
   onDisambiguationNeeded,
   onMissingConnection,
@@ -245,6 +246,7 @@ function useConnectionRefs({
         }
         result = await (0, _resolveConnections.resolveViaStaticRefs)({
           connectionReferences,
+          hasDataverse,
           schemaMap,
           environmentId,
           region,
@@ -314,7 +316,7 @@ function useConnectionRefs({
       if (retryTimer) clearTimeout(retryTimer);
     };
     // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [isSignedIn, retryTick, appId, environmentId, region, connectionReferences, schemaMap, isvClientId]);
+  }, [isSignedIn, retryTick, appId, environmentId, region, connectionReferences, hasDataverse, schemaMap, isvClientId]);
   return {
     connectionRefs,
     isReady,

package/lib/commonjs/index.js

@@ -399,6 +399,7 @@ Object.defineProperty(exports, "useThemeTokens", {
     return _ThemeProvider.useThemeTokens;
   }
 });
+require("@microsoft/power-apps-native-assets");
 var _NativePowerAppsBridge = require("./bridge/NativePowerAppsBridge.js");
 var _PowerPagesBridge = require("./bridge/PowerPagesBridge.js");
 var _setupNativeHost = require("./bridge/setupNativeHost.js");

package/lib/commonjs/offline/useOfflineIntegrationWithStartupGate.js

@@ -8,6 +8,7 @@ var _react = require("react");
 var _reactQuery = require("@tanstack/react-query");
 var _powerAppsNativeCommon = require("@microsoft/power-apps-native-common");
 var _DataverseGlobalDiscoveryApi = require("../platform/DataverseGlobalDiscoveryApi.js");
+var _DataverseDataSources = require("../platform/DataverseDataSources.js");
 var _index = require("../telemetry/index.js");
 var _createOfflineHostActivationCallbacks = require("./createOfflineHostActivationCallbacks.js");
 var _useOfflineIntegration = require("./useOfflineIntegration");
@@ -19,7 +20,8 @@ function useOfflineIntegrationWithStartupGate({
   isAuthReady
 }) {
   const queryClient = (0, _reactQuery.useQueryClient)();
-  const resolveInstanceUrl = (0, _react.useCallback)(async (environmentId, region, acqToken) => (await (0, _DataverseGlobalDiscoveryApi.fetchInstanceUrl)(environmentId, region, acqToken)) ?? null, []);
+  const hasDataverse = (0, _DataverseDataSources.hasDataverseDatabaseReferences)(powerConfig.databaseReferences);
+  const resolveInstanceUrl = (0, _react.useCallback)(async (environmentId, region, acqToken) => hasDataverse ? (await (0, _DataverseGlobalDiscoveryApi.fetchInstanceUrl)(environmentId, region, acqToken)) ?? null : null, [hasDataverse]);
   const hostActivationCallbacks = (0, _react.useMemo)(() => (0, _createOfflineHostActivationCallbacks.createOfflineHostActivationCallbacks)(queryClient), [queryClient]);
   const offline = (0, _useOfflineIntegration.useOfflineIntegration)({
     powerConfig,

package/lib/commonjs/platform/DataverseDataSources.js

@@ -4,6 +4,10 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.buildCdsDataSources = buildCdsDataSources;
+exports.hasDataverseDatabaseReferences = hasDataverseDatabaseReferences;
+function hasDataverseDatabaseReferences(databaseReferences) {
+  return Object.keys(databaseReferences ?? {}).length > 0;
+}
 function buildCdsDataSources(databaseReferences, dataverseOrgUrl) {
   return Object.values(databaseReferences).flatMap(databaseReference => Object.values(databaseReference.dataSources ?? {}).map(dataSource => ({
     runtimeUrl: dataverseOrgUrl ? `${dataverseOrgUrl}/api/data/v9.0/` : '',