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

package/lib/module/config/metroConfig.js

@@ -0,0 +1,65 @@
+"use strict";
+
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import { getDefaultConfig } from 'expo/metro-config.js';
+import { withPowerNativeMetroLogging } from "./metroLogger.js";
+function nativeRuntimeVersions(projectRoot) {
+  const appConfig = JSON.parse(fs.readFileSync(path.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(fs.readFileSync(path.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;
+}
+export function createPowerAppsMetroConfig(projectRoot, customize = config => config) {
+  const projectRequire = createRequire(path.join(projectRoot, 'package.json'));
+  const config = getDefaultConfig(projectRoot);
+  config.resolver.sourceExts = [...config.resolver.sourceExts, 'mjs'];
+  config.server = {
+    ...config.server,
+    enhanceMiddleware: middleware => 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: [path.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/module/config/metroLogger.js

@@ -0,0 +1,175 @@
+"use strict";
+
+import fs from 'node:fs';
+import path from 'node:path';
+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, '');
+}
+export 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 = path.resolve(projectRoot || process.cwd());
+  const logDir = path.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: path.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 = path.resolve(projectRoot || process.cwd());
+  const state = stateByRoot.get(root) || createMetroLogState(root, onError);
+  if (onError) state.onError = onError;
+  return state;
+}
+function appendMetroLog(state, value) {
+  try {
+    fs.mkdirSync(state.logDir, {
+      recursive: true
+    });
+    fs.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 = path.join(state.logDir, `metro-${state.stamp}-pid-${process.pid}-port-${state.port}.log`);
+  try {
+    fs.mkdirSync(state.logDir, {
+      recursive: true
+    });
+    if (fs.existsSync(previousPath) && previousPath !== state.logPath) {
+      fs.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;
+}
+export 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
+  };
+}
+export 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/module/config/tamaguiConfig.js

@@ -0,0 +1,93 @@
+"use strict";
+
+import { createTamagui } from '@tamagui/core';
+import { defaultConfig } from '@tamagui/config/v5';
+import { animations } from '@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';
+}
+export 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 = {
+  ...defaultConfig,
+  animations,
+  themes: {
+    ...defaultConfig.themes,
+    light: withPowerAppsSemanticAliases(defaultConfig.themes.light),
+    dark: withPowerAppsSemanticAliases(defaultConfig.themes.dark)
+  },
+  fonts: {
+    ...defaultConfig.fonts,
+    mono: defaultConfig.fonts.body
+  }
+};
+export function createPowerAppsTamaguiConfig(overrides = {}) {
+  return createTamagui({
+    ...powerAppsTamaguiDefaults,
+    ...overrides
+  });
+}