@garrix82/reactgenie-lib 1.3.0

package/dist/adapters/expo-router-adapter.js

@@ -0,0 +1,521 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildQueryParamsFromNavState = buildQueryParamsFromNavState;
+exports.getRegisteredRoutes = getRegisteredRoutes;
+exports.getRouteMap = getRouteMap;
+exports.isExpoRouterAvailable = isExpoRouterAvailable;
+exports.registerGenieRoute = registerGenieRoute;
+exports.useExpoRouterAdapter = useExpoRouterAdapter;
+exports.useRegisterGenieRoute = useRegisterGenieRoute;
+exports.withExpoRouterAdapter = withExpoRouterAdapter;
+var _react = _interopRequireWildcard(require("react"));
+var _sharedStore = require("../shared-store");
+var _reactgenieDsl = require("@garrix82/reactgenie-dsl");
+var _logger = require("../logger");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } /**
+ * Expo Router Adapter for ReactGenie
+ * 
+ * Automatically handles navigation compatibility between ReactGenie's
+ * programmatic navigation and expo-router's file-based routing.
+ * 
+ * Routes are auto-discovered from the actual file paths where components are used,
+ * not inferred from component names.
+ */
+// Try to import expo-router dynamically (optional peer dependency)
+let useRouter = null;
+let useSegments = null;
+let usePathname = null;
+let useLocalSearchParams = null;
+try {
+  const expoRouter = require('expo-router');
+  useRouter = expoRouter.useRouter;
+  useSegments = expoRouter.useSegments;
+  usePathname = expoRouter.usePathname;
+  useLocalSearchParams = expoRouter.useLocalSearchParams;
+} catch (e) {
+  // expo-router not available, adapter will be no-op
+}
+
+/**
+ * Route registration info with metadata for duplicate detection
+ */
+
+/**
+ * Internal function to reset navigation state
+ * Prevents infinite navigation loops by clearing navState after routing
+ */
+function resetGenieNavigation() {
+  (0, _reactgenieDsl.genieDispatch)(() => {
+    const reactGenieState = _reactgenieDsl.sharedState;
+    reactGenieState.navState = {
+      objectViewClassName: null,
+      objectConstructorParams: null,
+      queryIntent: null,
+      resultRef: null,
+      resultObjectType: null
+    };
+  });
+}
+
+/**
+ * Auto-discovered route registry built from actual file paths
+ * Maps decorator class names to their actual route file locations
+ * 
+ * Key: View class name (e.g., "CounterView")
+ * Value: Route registration info with path and duplicate detection
+ */
+const AUTO_ROUTE_REGISTRY = new Map();
+
+/**
+ * Extract dynamic segment names from an expo-router path.
+ * Examples:
+ * - /probes/[probeId] -> ["probeId"]
+ * - /files/[...path] -> ["path"]
+ * - /blog/[[...slug]] -> ["slug"]
+ */
+function getDynamicParamNames(routePath) {
+  if (!routePath) {
+    return [];
+  }
+
+  // Normalize optional catch-all segments: [[...slug]] -> [...slug]
+  const normalized = routePath.replace(/\[\[/g, '[').replace(/\]\]/g, ']');
+  const matches = normalized.match(/\[([^\]]+)\]/g) || [];
+  return matches.map(segment => segment.slice(1, -1).replace(/^\.\.\./, '')).filter(name => name.length > 0);
+}
+
+/**
+ * Keep only params that map to dynamic segments in the route path.
+ * This prevents extra Genie params from becoming query strings.
+ */
+function filterParamsForRoute(routePath, params) {
+  if (!params || typeof params !== 'object') {
+    return {};
+  }
+  const paramNames = getDynamicParamNames(routePath);
+  if (paramNames.length === 0) {
+    return {};
+  }
+  const filtered = {};
+  for (const name of paramNames) {
+    if (params[name] !== undefined && params[name] !== null) {
+      filtered[name] = params[name];
+    }
+  }
+  return filtered;
+}
+function sanitizeFieldName(field) {
+  return field.replace(/[^a-zA-Z0-9_.-]/g, '_');
+}
+function toQueryParamValue(value) {
+  if (value === null || value === undefined) return null;
+  if (typeof value === 'string') return value;
+  if (typeof value === 'number' || typeof value === 'boolean') return String(value);
+  return null;
+}
+function setQueryParam(params, key, value) {
+  const normalized = toQueryParamValue(value);
+  if (normalized === null) return;
+  let candidate = key;
+  let i = 1;
+  while (params[candidate] !== undefined) {
+    candidate = `${key}_${i}`;
+    i += 1;
+  }
+  params[candidate] = normalized;
+}
+function buildQueryParamsFromNavState(navState) {
+  const params = {};
+  if (navState.resultRef) {
+    params.rg_result = String(navState.resultRef);
+  }
+  if (navState.queryIntent?.hash) {
+    params.rg_qh = navState.queryIntent.hash;
+  }
+  const ops = navState.queryIntent?.ops ?? [];
+  for (const op of ops) {
+    if (op.kind === 'matching' || op.kind === 'contains' || op.kind === 'equals') {
+      setQueryParam(params, `q_${op.kind}_${sanitizeFieldName(op.field)}`, op.value);
+      continue;
+    }
+    if (op.kind === 'between') {
+      setQueryParam(params, `q_between_${sanitizeFieldName(op.field)}_from`, op.from);
+      setQueryParam(params, `q_between_${sanitizeFieldName(op.field)}_to`, op.to);
+      continue;
+    }
+    if (op.kind === 'sort') {
+      setQueryParam(params, 'q_sort', `${sanitizeFieldName(op.field)}:${op.ascending ? 'asc' : 'desc'}`);
+      continue;
+    }
+    if (op.kind === 'index') {
+      setQueryParam(params, 'q_index', op.value);
+      continue;
+    }
+    if (op.kind === 'length') {
+      setQueryParam(params, 'q_length', 'true');
+      continue;
+    }
+  }
+  return Object.keys(params).sort((a, b) => a.localeCompare(b)).reduce((acc, key) => {
+    acc[key] = params[key];
+    return acc;
+  }, {});
+}
+
+/**
+ * Type guard to check if a view class name has already been registered
+ */
+function isViewClassRegistered(viewClassName) {
+  return AUTO_ROUTE_REGISTRY.has(viewClassName);
+}
+
+/**
+ * Get registration info for a view class (for error messages)
+ */
+function getRegistrationInfo(viewClassName) {
+  return AUTO_ROUTE_REGISTRY.get(viewClassName);
+}
+
+/**
+ * Generate unique view class name for dynamic routes
+ * 
+ * Handles dynamic segments by appending normalized segment names:
+ * - /probes → "ProbeView"
+ * - /probes/[id] → "ProbeView_id"  
+ * - /probes/[id]/edit → "ProbeView_id_edit"
+ * - /probes/[slug]/comments/[commentId] → "ProbeView_slug_comments_commentId"
+ * 
+ * @param baseClassName - The base view class name (e.g., "ProbeView")
+ * @param routePath - The route path (e.g., "/probes/[id]")
+ * @returns Unique view class name
+ */
+function generateUniqueViewClassName(baseClassName, routePath) {
+  // Extract dynamic segments: [id], [slug], etc.
+  const dynamicSegments = routePath.match(/\[([^\]]+)\]/g);
+  if (!dynamicSegments || dynamicSegments.length === 0) {
+    // No dynamic segments, return base name
+    return baseClassName;
+  }
+
+  // Remove brackets and join with underscore
+  // [id] → id, [slug] → slug
+  const segmentNames = dynamicSegments.map(seg => seg.replace(/[\[\]]/g, '')).join('_');
+  return `${baseClassName}_${segmentNames}`;
+}
+
+/**
+ * Registers a route with its actual file path from expo-router
+ * 
+ * This should be called from route files (app directory), not from component files.
+ * The route path is auto-discovered from the file location.
+ * 
+ * **Duplicate Detection**: If a view class is already registered to a different route,
+ * a runtime error will be thrown with details about both registrations.
+ * 
+ * @param viewClassName - The name of the view class being rendered on this route
+ * @param routePath - Optional explicit path, otherwise auto-discovered from current route
+ * 
+ * @throws Error if viewClassName is already registered to a different route
+ * 
+ * @example
+ * // In app/genie/counter.tsx
+ * import { useRegisterGenieRoute } from '@garrix82/reactgenie-lib';
+ * 
+ * export default function CounterRoute() {
+ *   useRegisterGenieRoute('CounterView'); // Auto-discovers: /genie/counter
+ *   return <CounterView />;
+ * }
+ * 
+ * @example
+ * // Dynamic route: app/genie/[id].tsx
+ * export default function DynamicCounterRoute() {
+ *   useRegisterGenieRoute('CounterView'); // Auto-discovers: /genie/[id]
+ *   return <CounterView />;
+ * }
+ */
+function useRegisterGenieRoute(baseViewClassName, routePath) {
+  // Only works if expo-router is available
+  if (!usePathname) {
+    return;
+  }
+  const pathname = usePathname();
+  (0, _react.useEffect)(() => {
+    const path = routePath || pathname;
+    if (path && baseViewClassName) {
+      // Generate unique view class name for dynamic routes
+      const viewClassName = generateUniqueViewClassName(baseViewClassName, path);
+      const existingRegistration = getRegistrationInfo(viewClassName);
+
+      // Auto registry already owns this view class; ignore runtime registration.
+      if (existingRegistration && existingRegistration.source === "auto") {
+        if (routePath && existingRegistration.routePath !== path) {
+          console.warn(`[ReactGenie] Skipping runtime registration for "${viewClassName}" ` + `(${path}). Auto registry already mapped it to "${existingRegistration.routePath}".`);
+        }
+        return;
+      }
+
+      // Check for duplicate runtime registration
+      if (existingRegistration && existingRegistration.routePath !== path) {
+        const errorMsg = `[ReactGenie] ERROR: Duplicate registration detected!\n` + `View class "${viewClassName}" is already registered.\n\n` + `Existing registration:\n` + `  Route: ${existingRegistration.routePath}\n` + `  File: ${existingRegistration.registeredAt}\n\n` + `New registration attempt:\n` + `  Route: ${path}\n\n` + `Each view class can only be registered to ONE route.\n` + `Please use a different view class name for the second route,\n` + `or remove one of the registrations.`;
+        console.error(errorMsg);
+        throw new Error(errorMsg);
+      }
+
+      // Register the route with metadata
+      AUTO_ROUTE_REGISTRY.set(viewClassName, {
+        viewClassName,
+        routePath: path,
+        registeredAt: path,
+        // Use pathname as "file location"
+        source: "runtime"
+      });
+
+      // console.log(`[ReactGenie] Registered route: ${viewClassName} → ${path}`);
+    }
+  }, [baseViewClassName, pathname, routePath]);
+}
+
+/**
+ * Alternative: Register route without hook (for use outside React components)
+ * 
+ * **Duplicate Detection**: Throws error if view class already registered to different route.
+ * 
+ * @param viewClassName - The name of the view class
+ * @param routePath - The file-based route path where this view is used
+ * @throws Error if viewClassName is already registered to a different route
+ */
+function registerGenieRoute(viewClassName, routePath) {
+  // Check for duplicate registration
+  const existingRegistration = getRegistrationInfo(viewClassName);
+  if (existingRegistration && existingRegistration.routePath !== routePath) {
+    const errorMsg = `[ReactGenie] ERROR: Duplicate registration detected!\n` + `View class "${viewClassName}" is already registered.\n\n` + `Existing registration:\n` + `  Route: ${existingRegistration.routePath}\n` + `  File: ${existingRegistration.registeredAt}\n\n` + `New registration attempt:\n` + `  Route: ${routePath}\n\n` + `Each view class can only be registered to ONE route.\n` + `Please use a different view class name for the second route,\n` + `or remove one of the registrations.`;
+    console.error(errorMsg);
+    throw new Error(errorMsg);
+  }
+  AUTO_ROUTE_REGISTRY.set(viewClassName, {
+    viewClassName,
+    routePath,
+    registeredAt: routePath,
+    source: "auto"
+  });
+  // console.log(`[ReactGenie] Registered route: ${viewClassName} → ${routePath}`);
+}
+
+/**
+ * Gets the route path for a view class name
+ */
+function getRouteForView(viewClassName) {
+  const registration = AUTO_ROUTE_REGISTRY.get(viewClassName);
+  return registration?.routePath || null;
+}
+function splitRouteSegments(path) {
+  if (!path || path === '/') {
+    return [];
+  }
+  return path.split('/').filter(segment => segment.length > 0);
+}
+function isDynamicSegment(segment) {
+  return segment.startsWith('[') && segment.endsWith(']');
+}
+function isCatchAllSegment(segment) {
+  return segment.startsWith('[...') && segment.endsWith(']');
+}
+function isOptionalCatchAllSegment(segment) {
+  return segment.startsWith('[[...') && segment.endsWith(']]');
+}
+function routeTemplateMatchesPath(routeTemplate, pathname) {
+  const templateSegments = splitRouteSegments(routeTemplate);
+  const pathSegments = splitRouteSegments(pathname);
+  let templateIndex = 0;
+  let pathIndex = 0;
+  while (templateIndex < templateSegments.length) {
+    const templateSegment = templateSegments[templateIndex];
+    if (isOptionalCatchAllSegment(templateSegment)) {
+      return true;
+    }
+    if (isCatchAllSegment(templateSegment)) {
+      return pathIndex < pathSegments.length;
+    }
+    const pathSegment = pathSegments[pathIndex];
+    if (pathSegment === undefined) {
+      return false;
+    }
+    if (isDynamicSegment(templateSegment)) {
+      templateIndex += 1;
+      pathIndex += 1;
+      continue;
+    }
+    if (templateSegment !== pathSegment) {
+      return false;
+    }
+    templateIndex += 1;
+    pathIndex += 1;
+  }
+  return pathIndex === pathSegments.length;
+}
+function getRouteSpecificity(routeTemplate) {
+  const segments = splitRouteSegments(routeTemplate);
+  const staticSegments = segments.filter(segment => !isDynamicSegment(segment)).length;
+  return staticSegments * 100 + segments.length;
+}
+function getCurrentRouteTemplate(pathname) {
+  const candidates = [];
+  AUTO_ROUTE_REGISTRY.forEach(info => {
+    if (routeTemplateMatchesPath(info.routePath, pathname)) {
+      candidates.push(info.routePath);
+    }
+  });
+  if (candidates.length === 0) {
+    return null;
+  }
+  candidates.sort((a, b) => getRouteSpecificity(b) - getRouteSpecificity(a));
+  return candidates[0];
+}
+
+/**
+ * Hook that automatically intercepts ReactGenie navigation and routes via expo-router
+ * 
+ * Routes are auto-discovered from where components are actually used, not inferred.
+ * 
+ * Usage: Import and call in your root _layout.tsx (inside Provider context):
+ * ```tsx
+ * import { useExpoRouterAdapter } from '@garrix82/reactgenie-lib';
+ * 
+ * function RootLayoutContent() {
+ *   useExpoRouterAdapter(); // <- Add this line
+ *   // ... rest of layout
+ * }
+ * ```
+ */
+function useExpoRouterAdapter() {
+  // Check if expo-router is available
+  if (!useRouter || !useSegments) {
+    // No expo-router, navigation will fall back to react-navigation
+    return;
+  }
+  const router = useRouter();
+  const pathname = usePathname ? usePathname() : '';
+  const localSearchParams = useLocalSearchParams ? useLocalSearchParams() : {};
+  const navState = (0, _sharedStore.useGenieSelector)(state => state.navState);
+  const navStack = (0, _sharedStore.useGenieSelector)(state => state.navStack);
+  const lastHandledNavStackRef = (0, _react.useRef)(0);
+  (0, _react.useEffect)(() => {
+    if (!navState?.objectViewClassName) {
+      return;
+    }
+    if (navStack <= lastHandledNavStackRef.current) {
+      _logger.logger.debug(`[ReactGenieNav] reason=ignored_duplicate_event navStack=${navStack} lastHandled=${lastHandledNavStackRef.current}`);
+      return;
+    }
+    const eventId = navStack;
+    const viewClassName = navState.objectViewClassName;
+    const params = navState.objectConstructorParams;
+    try {
+      const routePath = getRouteForView(viewClassName);
+      if (!routePath) {
+        _logger.logger.warn(`[ReactGenieNav] reason=skipped_unregistered_view event=${eventId} view=${viewClassName}`);
+        return;
+      }
+      _logger.logger.debug(`[ReactGenie] Auto-routing: ${viewClassName} → ${routePath}`);
+      _logger.logger.debug(`[ReactGenie] Navigation params:`, params);
+      const routeParams = filterParamsForRoute(routePath, params);
+      const queryParams = buildQueryParamsFromNavState(navState);
+      const dynamicParamNames = getDynamicParamNames(routePath);
+      const missingParams = dynamicParamNames.filter(name => routeParams[name] === undefined || routeParams[name] === null);
+      if (dynamicParamNames.length > 0 && missingParams.length > 0) {
+        _logger.logger.warn(`[ReactGenieNav] reason=skipped_missing_params event=${eventId} view=${viewClassName} missing=${missingParams.join(',')}`);
+        return;
+      }
+      const activeTemplate = getCurrentRouteTemplate(pathname || '');
+      const dynamicParamsUnchanged = dynamicParamNames.every(name => {
+        const current = Array.isArray(localSearchParams?.[name]) ? localSearchParams[name][0] : localSearchParams?.[name];
+        return String(current ?? '') === String(routeParams[name] ?? '');
+      });
+      const shouldReplace = activeTemplate !== null && activeTemplate === routePath && dynamicParamsUnchanged;
+      const destinationParams = _objectSpread(_objectSpread({}, routeParams), queryParams);
+      const hasParams = Object.keys(destinationParams).length > 0;
+      if (hasParams) {
+        const destination = {
+          pathname: routePath,
+          params: destinationParams
+        };
+        if (shouldReplace && typeof router.replace === 'function') {
+          router.replace(destination);
+        } else {
+          router.push(destination);
+        }
+      } else if (shouldReplace && typeof router.replace === 'function') {
+        router.replace(routePath);
+      } else {
+        router.push(routePath);
+      }
+      _logger.logger.info(`[ReactGenieNav] reason=${shouldReplace ? 'handled_replace' : 'handled_push'} event=${eventId} view=${viewClassName} route=${routePath}`);
+    } catch (error) {
+      console.error(`[ReactGenie] Navigation error:`, error);
+    } finally {
+      lastHandledNavStackRef.current = eventId;
+      // Reset navigation state to prevent infinite loops after handling this event.
+      resetGenieNavigation();
+    }
+  }, [navStack, navState, pathname, localSearchParams, router]);
+}
+
+/**
+ * Higher-order component that wraps your root layout with expo-router adapter
+ * 
+ * Usage:
+ * ```tsx
+ * import { withExpoRouterAdapter } from '@garrix82/reactgenie-lib';
+ * 
+ * function RootLayout() {
+ *   return (
+ *     <Provider store={reactGenieStore}>
+ *       <Stack>...</Stack>
+ *     </Provider>
+ *   );
+ * }
+ * 
+ * export default withExpoRouterAdapter(RootLayout);
+ * ```
+ */
+function withExpoRouterAdapter(Component) {
+  return function ExpoRouterAdapterWrapper(props) {
+    useExpoRouterAdapter();
+    return /*#__PURE__*/_react.default.createElement(Component, props);
+  };
+}
+
+/**
+ * Utility to check if expo-router is available
+ */
+function isExpoRouterAvailable() {
+  return useRouter !== null && useSegments !== null;
+}
+
+/**
+ * Get all registered routes (for debugging)
+ * Returns a copy of the registration map with full metadata
+ */
+function getRegisteredRoutes() {
+  return new Map(AUTO_ROUTE_REGISTRY);
+}
+
+/**
+ * Get simple route map (viewClassName → routePath) for debugging
+ */
+function getRouteMap() {
+  const simpleMap = new Map();
+  AUTO_ROUTE_REGISTRY.forEach((info, viewClassName) => {
+    simpleMap.set(viewClassName, info.routePath);
+  });
+  return simpleMap;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireWildcard","require","_sharedStore","_reactgenieDsl","_logger","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","ownKeys","keys","getOwnPropertySymbols","filter","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty","getOwnPropertyDescriptors","defineProperties","_toPropertyKey","value","configurable","writable","_toPrimitive","Symbol","toPrimitive","TypeError","String","Number","useRouter","useSegments","usePathname","useLocalSearchParams","expoRouter","resetGenieNavigation","genieDispatch","reactGenieState","sharedState","navState","objectViewClassName","objectConstructorParams","queryIntent","resultRef","resultObjectType","AUTO_ROUTE_REGISTRY","Map","getDynamicParamNames","routePath","normalized","replace","matches","match","map","segment","slice","name","filterParamsForRoute","params","paramNames","filtered","undefined","sanitizeFieldName","field","toQueryParamValue","setQueryParam","key","candidate","buildQueryParamsFromNavState","rg_result","hash","rg_qh","ops","op","kind","from","to","ascending","sort","a","b","localeCompare","reduce","acc","isViewClassRegistered","viewClassName","getRegistrationInfo","generateUniqueViewClassName","baseClassName","dynamicSegments","segmentNames","seg","join","useRegisterGenieRoute","baseViewClassName","pathname","useEffect","path","existingRegistration","source","console","warn","errorMsg","registeredAt","error","Error","registerGenieRoute","getRouteForView","registration","splitRouteSegments","split","isDynamicSegment","startsWith","endsWith","isCatchAllSegment","isOptionalCatchAllSegment","routeTemplateMatchesPath","routeTemplate","templateSegments","pathSegments","templateIndex","pathIndex","templateSegment","pathSegment","getRouteSpecificity","segments","staticSegments","getCurrentRouteTemplate","candidates","info","useExpoRouterAdapter","router","localSearchParams","useGenieSelector","state","navStack","lastHandledNavStackRef","useRef","current","logger","debug","eventId","routeParams","queryParams","dynamicParamNames","missingParams","activeTemplate","dynamicParamsUnchanged","every","Array","isArray","shouldReplace","destinationParams","hasParams","destination","withExpoRouterAdapter","Component","ExpoRouterAdapterWrapper","props","createElement","isExpoRouterAvailable","getRegisteredRoutes","getRouteMap","simpleMap"],"sources":["../../src/adapters/expo-router-adapter.tsx"],"sourcesContent":["/**\n * Expo Router Adapter for ReactGenie\n * \n * Automatically handles navigation compatibility between ReactGenie's\n * programmatic navigation and expo-router's file-based routing.\n * \n * Routes are auto-discovered from the actual file paths where components are used,\n * not inferred from component names.\n */\n\nimport React, { useEffect, useRef } from 'react';\nimport { useGenieSelector } from '../shared-store';\nimport { genieDispatch, sharedState } from '@garrix82/reactgenie-dsl';\nimport type { ReactGenieState, NavigatorState } from '../shared-store';\nimport { logger } from '../logger';\n\n// Try to import expo-router dynamically (optional peer dependency)\nlet useRouter: any = null;\nlet useSegments: any = null;\nlet usePathname: any = null;\nlet useLocalSearchParams: any = null;\n\ntry {\n  const expoRouter = require('expo-router');\n  useRouter = expoRouter.useRouter;\n  useSegments = expoRouter.useSegments;\n  usePathname = expoRouter.usePathname;\n  useLocalSearchParams = expoRouter.useLocalSearchParams;\n} catch (e) {\n  // expo-router not available, adapter will be no-op\n}\n\n/**\n * Route registration info with metadata for duplicate detection\n */\nexport type RouteRegistrationInfo = {\n  readonly viewClassName: string;\n  readonly routePath: string;\n  readonly registeredAt: string;\n  readonly source: \"auto\" | \"runtime\";\n};\n\n/**\n * Internal function to reset navigation state\n * Prevents infinite navigation loops by clearing navState after routing\n */\nfunction resetGenieNavigation() {\n  genieDispatch(() => {\n    const reactGenieState = sharedState as ReactGenieState;\n    reactGenieState.navState = {\n      objectViewClassName: null,\n      objectConstructorParams: null,\n      queryIntent: null,\n      resultRef: null,\n      resultObjectType: null,\n    };\n  });\n}\n\n/**\n * Auto-discovered route registry built from actual file paths\n * Maps decorator class names to their actual route file locations\n * \n * Key: View class name (e.g., \"CounterView\")\n * Value: Route registration info with path and duplicate detection\n */\nconst AUTO_ROUTE_REGISTRY = new Map<string, RouteRegistrationInfo>();\n\n/**\n * Extract dynamic segment names from an expo-router path.\n * Examples:\n * - /probes/[probeId] -> [\"probeId\"]\n * - /files/[...path] -> [\"path\"]\n * - /blog/[[...slug]] -> [\"slug\"]\n */\nfunction getDynamicParamNames(routePath: string): string[] {\n  if (!routePath) {\n    return [];\n  }\n\n  // Normalize optional catch-all segments: [[...slug]] -> [...slug]\n  const normalized = routePath.replace(/\\[\\[/g, '[').replace(/\\]\\]/g, ']');\n  const matches = normalized.match(/\\[([^\\]]+)\\]/g) || [];\n\n  return matches\n    .map((segment) => segment.slice(1, -1).replace(/^\\.\\.\\./, ''))\n    .filter((name) => name.length > 0);\n}\n\n/**\n * Keep only params that map to dynamic segments in the route path.\n * This prevents extra Genie params from becoming query strings.\n */\nfunction filterParamsForRoute(routePath: string, params: any): Record<string, any> {\n  if (!params || typeof params !== 'object') {\n    return {};\n  }\n\n  const paramNames = getDynamicParamNames(routePath);\n  if (paramNames.length === 0) {\n    return {};\n  }\n\n  const filtered: Record<string, any> = {};\n  for (const name of paramNames) {\n    if (params[name] !== undefined && params[name] !== null) {\n      filtered[name] = params[name];\n    }\n  }\n\n  return filtered;\n}\n\nfunction sanitizeFieldName(field: string): string {\n  return field.replace(/[^a-zA-Z0-9_.-]/g, '_');\n}\n\nfunction toQueryParamValue(value: unknown): string | null {\n  if (value === null || value === undefined) return null;\n  if (typeof value === 'string') return value;\n  if (typeof value === 'number' || typeof value === 'boolean') return String(value);\n  return null;\n}\n\nfunction setQueryParam(params: Record<string, string>, key: string, value: unknown) {\n  const normalized = toQueryParamValue(value);\n  if (normalized === null) return;\n  let candidate = key;\n  let i = 1;\n  while (params[candidate] !== undefined) {\n    candidate = `${key}_${i}`;\n    i += 1;\n  }\n  params[candidate] = normalized;\n}\n\nexport function buildQueryParamsFromNavState(\n  navState: NavigatorState,\n): Record<string, string> {\n  const params: Record<string, string> = {};\n\n  if (navState.resultRef) {\n    params.rg_result = String(navState.resultRef);\n  }\n\n  if (navState.queryIntent?.hash) {\n    params.rg_qh = navState.queryIntent.hash;\n  }\n\n  const ops = navState.queryIntent?.ops ?? [];\n  for (const op of ops) {\n    if (op.kind === 'matching' || op.kind === 'contains' || op.kind === 'equals') {\n      setQueryParam(params, `q_${op.kind}_${sanitizeFieldName(op.field)}`, op.value);\n      continue;\n    }\n\n    if (op.kind === 'between') {\n      setQueryParam(params, `q_between_${sanitizeFieldName(op.field)}_from`, op.from);\n      setQueryParam(params, `q_between_${sanitizeFieldName(op.field)}_to`, op.to);\n      continue;\n    }\n\n    if (op.kind === 'sort') {\n      setQueryParam(\n        params,\n        'q_sort',\n        `${sanitizeFieldName(op.field)}:${op.ascending ? 'asc' : 'desc'}`\n      );\n      continue;\n    }\n\n    if (op.kind === 'index') {\n      setQueryParam(params, 'q_index', op.value);\n      continue;\n    }\n\n    if (op.kind === 'length') {\n      setQueryParam(params, 'q_length', 'true');\n      continue;\n    }\n  }\n\n  return Object.keys(params)\n    .sort((a, b) => a.localeCompare(b))\n    .reduce<Record<string, string>>((acc, key) => {\n      acc[key] = params[key];\n      return acc;\n    }, {});\n}\n\n/**\n * Type guard to check if a view class name has already been registered\n */\nfunction isViewClassRegistered(viewClassName: string): boolean {\n  return AUTO_ROUTE_REGISTRY.has(viewClassName);\n}\n\n/**\n * Get registration info for a view class (for error messages)\n */\nfunction getRegistrationInfo(viewClassName: string): RouteRegistrationInfo | undefined {\n  return AUTO_ROUTE_REGISTRY.get(viewClassName);\n}\n\n/**\n * Generate unique view class name for dynamic routes\n * \n * Handles dynamic segments by appending normalized segment names:\n * - /probes → \"ProbeView\"\n * - /probes/[id] → \"ProbeView_id\"  \n * - /probes/[id]/edit → \"ProbeView_id_edit\"\n * - /probes/[slug]/comments/[commentId] → \"ProbeView_slug_comments_commentId\"\n * \n * @param baseClassName - The base view class name (e.g., \"ProbeView\")\n * @param routePath - The route path (e.g., \"/probes/[id]\")\n * @returns Unique view class name\n */\nfunction generateUniqueViewClassName(baseClassName: string, routePath: string): string {\n  // Extract dynamic segments: [id], [slug], etc.\n  const dynamicSegments = routePath.match(/\\[([^\\]]+)\\]/g);\n  \n  if (!dynamicSegments || dynamicSegments.length === 0) {\n    // No dynamic segments, return base name\n    return baseClassName;\n  }\n  \n  // Remove brackets and join with underscore\n  // [id] → id, [slug] → slug\n  const segmentNames = dynamicSegments\n    .map(seg => seg.replace(/[\\[\\]]/g, ''))\n    .join('_');\n  \n  return `${baseClassName}_${segmentNames}`;\n}\n\n/**\n * Registers a route with its actual file path from expo-router\n * \n * This should be called from route files (app directory), not from component files.\n * The route path is auto-discovered from the file location.\n * \n * **Duplicate Detection**: If a view class is already registered to a different route,\n * a runtime error will be thrown with details about both registrations.\n * \n * @param viewClassName - The name of the view class being rendered on this route\n * @param routePath - Optional explicit path, otherwise auto-discovered from current route\n * \n * @throws Error if viewClassName is already registered to a different route\n * \n * @example\n * // In app/genie/counter.tsx\n * import { useRegisterGenieRoute } from '@garrix82/reactgenie-lib';\n * \n * export default function CounterRoute() {\n *   useRegisterGenieRoute('CounterView'); // Auto-discovers: /genie/counter\n *   return <CounterView />;\n * }\n * \n * @example\n * // Dynamic route: app/genie/[id].tsx\n * export default function DynamicCounterRoute() {\n *   useRegisterGenieRoute('CounterView'); // Auto-discovers: /genie/[id]\n *   return <CounterView />;\n * }\n */\nexport function useRegisterGenieRoute(baseViewClassName: string, routePath?: string) {\n  // Only works if expo-router is available\n  if (!usePathname) {\n    return;\n  }\n\n  const pathname = usePathname();\n  \n  useEffect(() => {\n    const path = routePath || pathname;\n    \n    if (path && baseViewClassName) {\n      // Generate unique view class name for dynamic routes\n      const viewClassName = generateUniqueViewClassName(baseViewClassName, path);\n      \n      const existingRegistration = getRegistrationInfo(viewClassName);\n\n      // Auto registry already owns this view class; ignore runtime registration.\n      if (existingRegistration && existingRegistration.source === \"auto\") {\n        if (routePath && existingRegistration.routePath !== path) {\n          console.warn(\n            `[ReactGenie] Skipping runtime registration for \"${viewClassName}\" ` +\n            `(${path}). Auto registry already mapped it to \"${existingRegistration.routePath}\".`\n          );\n        }\n        return;\n      }\n\n      // Check for duplicate runtime registration\n      if (existingRegistration && existingRegistration.routePath !== path) {\n        const errorMsg = \n          `[ReactGenie] ERROR: Duplicate registration detected!\\n` +\n          `View class \"${viewClassName}\" is already registered.\\n\\n` +\n          `Existing registration:\\n` +\n          `  Route: ${existingRegistration.routePath}\\n` +\n          `  File: ${existingRegistration.registeredAt}\\n\\n` +\n          `New registration attempt:\\n` +\n          `  Route: ${path}\\n\\n` +\n          `Each view class can only be registered to ONE route.\\n` +\n          `Please use a different view class name for the second route,\\n` +\n          `or remove one of the registrations.`;\n        \n        console.error(errorMsg);\n        throw new Error(errorMsg);\n      }\n      \n      // Register the route with metadata\n      AUTO_ROUTE_REGISTRY.set(viewClassName, {\n        viewClassName,\n        routePath: path,\n        registeredAt: path, // Use pathname as \"file location\"\n        source: \"runtime\",\n      });\n      \n      // console.log(`[ReactGenie] Registered route: ${viewClassName} → ${path}`);\n    }\n  }, [baseViewClassName, pathname, routePath]);\n}\n\n/**\n * Alternative: Register route without hook (for use outside React components)\n * \n * **Duplicate Detection**: Throws error if view class already registered to different route.\n * \n * @param viewClassName - The name of the view class\n * @param routePath - The file-based route path where this view is used\n * @throws Error if viewClassName is already registered to a different route\n */\nexport function registerGenieRoute(viewClassName: string, routePath: string) {\n  // Check for duplicate registration\n  const existingRegistration = getRegistrationInfo(viewClassName);\n  \n  if (existingRegistration && existingRegistration.routePath !== routePath) {\n    const errorMsg = \n      `[ReactGenie] ERROR: Duplicate registration detected!\\n` +\n      `View class \"${viewClassName}\" is already registered.\\n\\n` +\n      `Existing registration:\\n` +\n      `  Route: ${existingRegistration.routePath}\\n` +\n      `  File: ${existingRegistration.registeredAt}\\n\\n` +\n      `New registration attempt:\\n` +\n      `  Route: ${routePath}\\n\\n` +\n      `Each view class can only be registered to ONE route.\\n` +\n      `Please use a different view class name for the second route,\\n` +\n      `or remove one of the registrations.`;\n    \n    console.error(errorMsg);\n    throw new Error(errorMsg);\n  }\n  \n  AUTO_ROUTE_REGISTRY.set(viewClassName, {\n    viewClassName,\n    routePath,\n    registeredAt: routePath,\n    source: \"auto\",\n  });\n  // console.log(`[ReactGenie] Registered route: ${viewClassName} → ${routePath}`);\n}\n\n/**\n * Gets the route path for a view class name\n */\nfunction getRouteForView(viewClassName: string): string | null {\n  const registration = AUTO_ROUTE_REGISTRY.get(viewClassName);\n  return registration?.routePath || null;\n}\n\nfunction splitRouteSegments(path: string): string[] {\n  if (!path || path === '/') {\n    return [];\n  }\n  return path\n    .split('/')\n    .filter((segment) => segment.length > 0);\n}\n\nfunction isDynamicSegment(segment: string): boolean {\n  return segment.startsWith('[') && segment.endsWith(']');\n}\n\nfunction isCatchAllSegment(segment: string): boolean {\n  return segment.startsWith('[...') && segment.endsWith(']');\n}\n\nfunction isOptionalCatchAllSegment(segment: string): boolean {\n  return segment.startsWith('[[...') && segment.endsWith(']]');\n}\n\nfunction routeTemplateMatchesPath(routeTemplate: string, pathname: string): boolean {\n  const templateSegments = splitRouteSegments(routeTemplate);\n  const pathSegments = splitRouteSegments(pathname);\n\n  let templateIndex = 0;\n  let pathIndex = 0;\n\n  while (templateIndex < templateSegments.length) {\n    const templateSegment = templateSegments[templateIndex];\n\n    if (isOptionalCatchAllSegment(templateSegment)) {\n      return true;\n    }\n\n    if (isCatchAllSegment(templateSegment)) {\n      return pathIndex < pathSegments.length;\n    }\n\n    const pathSegment = pathSegments[pathIndex];\n    if (pathSegment === undefined) {\n      return false;\n    }\n\n    if (isDynamicSegment(templateSegment)) {\n      templateIndex += 1;\n      pathIndex += 1;\n      continue;\n    }\n\n    if (templateSegment !== pathSegment) {\n      return false;\n    }\n\n    templateIndex += 1;\n    pathIndex += 1;\n  }\n\n  return pathIndex === pathSegments.length;\n}\n\nfunction getRouteSpecificity(routeTemplate: string): number {\n  const segments = splitRouteSegments(routeTemplate);\n  const staticSegments = segments.filter((segment) => !isDynamicSegment(segment)).length;\n  return staticSegments * 100 + segments.length;\n}\n\nfunction getCurrentRouteTemplate(pathname: string): string | null {\n  const candidates: string[] = [];\n\n  AUTO_ROUTE_REGISTRY.forEach((info) => {\n    if (routeTemplateMatchesPath(info.routePath, pathname)) {\n      candidates.push(info.routePath);\n    }\n  });\n\n  if (candidates.length === 0) {\n    return null;\n  }\n\n  candidates.sort((a, b) => getRouteSpecificity(b) - getRouteSpecificity(a));\n  return candidates[0];\n}\n\n/**\n * Hook that automatically intercepts ReactGenie navigation and routes via expo-router\n * \n * Routes are auto-discovered from where components are actually used, not inferred.\n * \n * Usage: Import and call in your root _layout.tsx (inside Provider context):\n * ```tsx\n * import { useExpoRouterAdapter } from '@garrix82/reactgenie-lib';\n * \n * function RootLayoutContent() {\n *   useExpoRouterAdapter(); // <- Add this line\n *   // ... rest of layout\n * }\n * ```\n */\nexport function useExpoRouterAdapter() {\n  // Check if expo-router is available\n  if (!useRouter || !useSegments) {\n    // No expo-router, navigation will fall back to react-navigation\n    return;\n  }\n\n  const router = useRouter();\n  const pathname = usePathname ? usePathname() : '';\n  const localSearchParams = useLocalSearchParams ? useLocalSearchParams() : {};\n  const navState = useGenieSelector((state: any) => state.navState as NavigatorState | null);\n  const navStack = useGenieSelector((state: any) => state.navStack as number);\n  const lastHandledNavStackRef = useRef<number>(0);\n\n  useEffect(() => {\n    if (!navState?.objectViewClassName) {\n      return;\n    }\n\n    if (navStack <= lastHandledNavStackRef.current) {\n      logger.debug(\n        `[ReactGenieNav] reason=ignored_duplicate_event navStack=${navStack} lastHandled=${lastHandledNavStackRef.current}`\n      );\n      return;\n    }\n\n    const eventId = navStack;\n    const viewClassName = navState.objectViewClassName;\n    const params = navState.objectConstructorParams;\n\n    try {\n      const routePath = getRouteForView(viewClassName);\n      if (!routePath) {\n        logger.warn(\n          `[ReactGenieNav] reason=skipped_unregistered_view event=${eventId} view=${viewClassName}`\n        );\n        return;\n      }\n\n      logger.debug(`[ReactGenie] Auto-routing: ${viewClassName} → ${routePath}`);\n      logger.debug(`[ReactGenie] Navigation params:`, params);\n\n      const routeParams = filterParamsForRoute(routePath, params);\n      const queryParams = buildQueryParamsFromNavState(navState);\n      const dynamicParamNames = getDynamicParamNames(routePath);\n      const missingParams = dynamicParamNames.filter(\n        (name) => routeParams[name] === undefined || routeParams[name] === null\n      );\n\n      if (dynamicParamNames.length > 0 && missingParams.length > 0) {\n        logger.warn(\n          `[ReactGenieNav] reason=skipped_missing_params event=${eventId} view=${viewClassName} missing=${missingParams.join(',')}`\n        );\n        return;\n      }\n\n      const activeTemplate = getCurrentRouteTemplate(pathname || '');\n      const dynamicParamsUnchanged = dynamicParamNames.every((name) => {\n        const current = Array.isArray((localSearchParams as any)?.[name])\n          ? (localSearchParams as any)[name][0]\n          : (localSearchParams as any)?.[name];\n        return String(current ?? '') === String(routeParams[name] ?? '');\n      });\n      const shouldReplace =\n        activeTemplate !== null &&\n        activeTemplate === routePath &&\n        dynamicParamsUnchanged;\n\n      const destinationParams = {\n        ...routeParams,\n        ...queryParams,\n      };\n      const hasParams = Object.keys(destinationParams).length > 0;\n\n      if (hasParams) {\n        const destination = {\n          pathname: routePath as any,\n          params: destinationParams,\n        };\n        if (shouldReplace && typeof router.replace === 'function') {\n          router.replace(destination);\n        } else {\n          router.push(destination);\n        }\n      } else if (shouldReplace && typeof router.replace === 'function') {\n        router.replace(routePath as any);\n      } else {\n        router.push(routePath as any);\n      }\n\n      logger.info(\n        `[ReactGenieNav] reason=${shouldReplace ? 'handled_replace' : 'handled_push'} event=${eventId} view=${viewClassName} route=${routePath}`\n      );\n    } catch (error) {\n      console.error(`[ReactGenie] Navigation error:`, error);\n    } finally {\n      lastHandledNavStackRef.current = eventId;\n      // Reset navigation state to prevent infinite loops after handling this event.\n      resetGenieNavigation();\n    }\n  }, [navStack, navState, pathname, localSearchParams, router]);\n}\n\n/**\n * Higher-order component that wraps your root layout with expo-router adapter\n * \n * Usage:\n * ```tsx\n * import { withExpoRouterAdapter } from '@garrix82/reactgenie-lib';\n * \n * function RootLayout() {\n *   return (\n *     <Provider store={reactGenieStore}>\n *       <Stack>...</Stack>\n *     </Provider>\n *   );\n * }\n * \n * export default withExpoRouterAdapter(RootLayout);\n * ```\n */\nexport function withExpoRouterAdapter<P extends object>(\n  Component: React.ComponentType<P>\n): React.ComponentType<P> {\n  return function ExpoRouterAdapterWrapper(props: P) {\n    useExpoRouterAdapter();\n    return <Component {...props} />;\n  };\n}\n\n/**\n * Utility to check if expo-router is available\n */\nexport function isExpoRouterAvailable(): boolean {\n  return useRouter !== null && useSegments !== null;\n}\n\n/**\n * Get all registered routes (for debugging)\n * Returns a copy of the registration map with full metadata\n */\nexport function getRegisteredRoutes(): Map<string, RouteRegistrationInfo> {\n  return new Map(AUTO_ROUTE_REGISTRY);\n}\n\n/**\n * Get simple route map (viewClassName → routePath) for debugging\n */\nexport function getRouteMap(): Map<string, string> {\n  const simpleMap = new Map<string, string>();\n  AUTO_ROUTE_REGISTRY.forEach((info, viewClassName) => {\n    simpleMap.set(viewClassName, info.routePath);\n  });\n  return simpleMap;\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/adapters/navigation-adapter.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+export interface NavigationAdapter {
+    push: (routeName: string, params?: any) => void;
+    navigate: (routeName: string, params?: any) => void;
+    goBack: () => void;
+    canGoBack: () => boolean;
+    setOptions: (options: any) => void;
+    getState: () => any;
+}
+export declare function useNavigationAdapter(): NavigationAdapter;
+export declare function withNavigationAdapter<P extends object>(Component: React.ComponentType<P & {
+    navigation: NavigationAdapter;
+}>): React.FC<P>;
+export declare function useRouteParams<T = any>(): T;
+export declare function createScreenWrapper(Screen: React.ComponentType<any>, options?: {
+    title?: (params?: any) => string;
+    headerShown?: boolean;
+}): (props: any) => any;
+export declare function isExpoRouter(): boolean;
+export type { NavigationAdapter as Navigation };