flowboard-react 0.6.1 → 0.6.3

package/src/native/runtime.ts

@@ -0,0 +1,110 @@
+import { NativeModules, UIManager } from 'react-native';
+
+const warnedMessages = new Set<string>();
+const reactNativeModule = require('react-native') as {
+  TurboModuleRegistry?: {
+    get?: (name: string) => unknown;
+    getEnforcing?: (name: string) => unknown;
+  };
+};
+
+export const ZERO_INSETS = {
+  top: 0,
+  right: 0,
+  bottom: 0,
+  left: 0,
+} as const;
+
+function isDevelopment(): boolean {
+  if (typeof __DEV__ !== 'undefined') return __DEV__;
+  return process.env.NODE_ENV !== 'production';
+}
+
+export function warnOnce(key: string, message: string): void {
+  if (!isDevelopment() || warnedMessages.has(key)) return;
+  warnedMessages.add(key);
+  console.warn(`[flowboard-react] ${message}`);
+}
+
+export function hasTurboModule(name: string): boolean {
+  const registry = reactNativeModule.TurboModuleRegistry;
+  if (!registry) return false;
+  try {
+    if (typeof registry.get === 'function' && registry.get(name)) {
+      return true;
+    }
+  } catch {
+    return false;
+  }
+  try {
+    if (typeof registry.getEnforcing === 'function') {
+      return Boolean(registry.getEnforcing(name));
+    }
+  } catch {
+    return false;
+  }
+  return false;
+}
+
+export function hasNativeModule(...names: string[]): boolean {
+  const modules = NativeModules as Record<string, unknown>;
+  return names.some((name) => Boolean(modules[name]) || hasTurboModule(name));
+}
+
+export function hasViewManager(...names: string[]): boolean {
+  const uiManager = UIManager as unknown as {
+    getViewManagerConfig?: (name: string) => unknown;
+    [key: string]: unknown;
+  };
+
+  return names.some((name) => {
+    try {
+      if (typeof uiManager.getViewManagerConfig === 'function') {
+        return Boolean(uiManager.getViewManagerConfig(name));
+      }
+      return Boolean(uiManager[name]);
+    } catch {
+      return false;
+    }
+  });
+}
+
+export function safeSync<T>(
+  key: string,
+  available: boolean,
+  run: () => T,
+  fallback: T,
+  warning: string
+): T {
+  if (!available) {
+    warnOnce(key, warning);
+    return fallback;
+  }
+
+  try {
+    return run();
+  } catch {
+    warnOnce(key, warning);
+    return fallback;
+  }
+}
+
+export async function safeAsync<T>(
+  key: string,
+  available: boolean,
+  run: () => Promise<T>,
+  fallback: T,
+  warning: string
+): Promise<T> {
+  if (!available) {
+    warnOnce(key, warning);
+    return fallback;
+  }
+
+  try {
+    return await run();
+  } catch {
+    warnOnce(key, warning);
+    return fallback;
+  }
+}

package/src/native/safeAreaContext.tsx

@@ -0,0 +1,44 @@
+import { View } from 'react-native';
+import {
+  SafeAreaProvider as NativeSafeAreaProvider,
+  SafeAreaView as NativeSafeAreaView,
+  useSafeAreaInsets as nativeUseSafeAreaInsets,
+} from 'react-native-safe-area-context';
+import { hasViewManager, warnOnce, ZERO_INSETS } from './runtime';
+
+const warning =
+  'react-native-safe-area-context is unavailable. Flowboard will render without device safe-area insets until native setup is fixed.';
+
+export const safeAreaContextAvailable = hasViewManager('RNCSafeAreaProvider');
+
+export function SafeAreaProvider(props: any) {
+  if (!safeAreaContextAvailable) {
+    warnOnce('native-safe-area-provider', warning);
+    return <>{props.children}</>;
+  }
+
+  return <NativeSafeAreaProvider {...props} />;
+}
+
+export function SafeAreaView(props: any) {
+  if (!safeAreaContextAvailable) {
+    warnOnce('native-safe-area-view', warning);
+    return <View {...props} />;
+  }
+
+  return <NativeSafeAreaView {...props} />;
+}
+
+export function useSafeAreaInsets() {
+  if (!safeAreaContextAvailable) {
+    warnOnce('native-safe-area-insets', warning);
+    return ZERO_INSETS;
+  }
+
+  try {
+    return nativeUseSafeAreaInsets();
+  } catch {
+    warnOnce('native-safe-area-insets-error', warning);
+    return ZERO_INSETS;
+  }
+}

package/src/native/svg.tsx

@@ -0,0 +1,82 @@
+import { Text as ReactNativeText, View } from 'react-native';
+import NativeSvg, {
+  Circle as NativeCircle,
+  G as NativeG,
+  Line as NativeLine,
+  Polygon as NativePolygon,
+  Text as NativeSvgText,
+} from 'react-native-svg';
+import { hasViewManager, warnOnce } from './runtime';
+
+const warning =
+  'react-native-svg is unavailable. Flowboard will fall back to simplified chart rendering until native setup is fixed.';
+
+export const svgAvailable = hasViewManager(
+  'RNSVGSvgView',
+  'RNSVGSvgViewAndroid'
+);
+
+function NullShape() {
+  return null;
+}
+
+export default function Svg(props: any) {
+  if (!svgAvailable) {
+    warnOnce('native-svg-root', warning);
+    const { children, height, style, width } = props;
+    return (
+      <View
+        style={[style, width ? { width } : null, height ? { height } : null]}
+      >
+        {children}
+      </View>
+    );
+  }
+
+  return <NativeSvg {...props} />;
+}
+
+export function Circle(props: any) {
+  if (!svgAvailable) {
+    warnOnce('native-svg-circle', warning);
+    return <NullShape />;
+  }
+
+  return <NativeCircle {...props} />;
+}
+
+export function G(props: any) {
+  if (!svgAvailable) {
+    warnOnce('native-svg-group', warning);
+    return <>{props.children}</>;
+  }
+
+  return <NativeG {...props} />;
+}
+
+export function Line(props: any) {
+  if (!svgAvailable) {
+    warnOnce('native-svg-line', warning);
+    return <NullShape />;
+  }
+
+  return <NativeLine {...props} />;
+}
+
+export function Polygon(props: any) {
+  if (!svgAvailable) {
+    warnOnce('native-svg-polygon', warning);
+    return <NullShape />;
+  }
+
+  return <NativePolygon {...props} />;
+}
+
+export function SvgText(props: any) {
+  if (!svgAvailable) {
+    warnOnce('native-svg-text', warning);
+    return <ReactNativeText>{props.children}</ReactNativeText>;
+  }
+
+  return <NativeSvgText {...props} />;
+}

package/src/native/vectorIcons.tsx

@@ -0,0 +1,50 @@
+import React from 'react';
+import NativeFontAwesome6 from 'react-native-vector-icons/FontAwesome6';
+import { hasNativeModule, warnOnce } from './runtime';
+
+const warning =
+  'react-native-vector-icons could not load FontAwesome6 fonts. Verify the package is installed and fonts are bundled in the host app.';
+
+let attemptedFontLoad = false;
+
+export const vectorIconsNativeAvailable = hasNativeModule(
+  'RNVectorIcons',
+  'RNVectorIconsManager'
+);
+
+function ensureFontLoaded(): void {
+  if (attemptedFontLoad) return;
+  attemptedFontLoad = true;
+
+  const anyIcon = NativeFontAwesome6 as any;
+  if (typeof anyIcon.loadFont !== 'function') return;
+
+  Promise.resolve(anyIcon.loadFont()).catch(() => {
+    warnOnce('native-vector-icons-load-font', warning);
+  });
+}
+
+export function getFontAwesomeGlyphMap(): Record<string, number> | null {
+  const anyIcon = NativeFontAwesome6 as any;
+
+  try {
+    if (typeof anyIcon.getRawGlyphMap === 'function') {
+      return anyIcon.getRawGlyphMap();
+    }
+    if (anyIcon.glyphMap) {
+      return anyIcon.glyphMap as Record<string, number>;
+    }
+  } catch {
+    warnOnce('native-vector-icons-glyph-map', warning);
+  }
+
+  return null;
+}
+
+export function FontAwesome6(props: any) {
+  React.useEffect(() => {
+    ensureFontLoaded();
+  }, []);
+
+  return <NativeFontAwesome6 {...props} />;
+}

package/src/utils/flowboardUtils.ts

@@ -91,7 +91,15 @@ export function parseDimension(
     return value;
   }
   if (typeof value === 'string') {
-    if (value.toLowerCase() === 'infinity') return Number.POSITIVE_INFINITY;
+    const normalized = value.trim().toLowerCase();
+    if (
+      normalized === 'infinity' ||
+      normalized === 'infinite' ||
+      normalized === 'double.infinity' ||
+      normalized === '+infinity'
+    ) {
+      return Number.POSITIVE_INFINITY;
+    }
     const numeric = Number(value);
     if (!Number.isNaN(numeric)) {
       if (zeroIsNull && numeric === 0) return undefined;