zelune 1.5.1 → 1.5.4

package/vite.config.ts

@@ -6,6 +6,7 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { viteRnSourceInject } from './plugins/viteRnSourceInject';
 import { viteVirtualScreensPlugin } from './plugins/viteVirtualScreensPlugin';
+import { viteReactNativeFallbackPlugin } from './plugins/viteReactNativeFallbackPlugin';
 import { viteCanvasApiMiddleware } from './src/server/apiMiddleware';
 import { findMobileAppRoot } from './src/server/astEngine';
 
@@ -16,9 +17,21 @@ const rawTargetRoot = process.env.ANTIGRAVITY_TARGET_PROJECT
   ? path.resolve(process.env.ANTIGRAVITY_TARGET_PROJECT)
   : __dirname;
 
+const workspaceRoot = process.env.ANTIGRAVITY_WORKSPACE_ROOT
+  ? path.resolve(process.env.ANTIGRAVITY_WORKSPACE_ROOT)
+  : rawTargetRoot;
+
 const targetProjectRoot = findMobileAppRoot(rawTargetRoot);
 const mockNavShimPath = path.resolve(__dirname, 'src/runtime/MockNavigationContext.tsx');
 
+function safeRealpath(targetPath: string): string {
+  try {
+    return fs.realpathSync(targetPath);
+  } catch {
+    return path.resolve(targetPath);
+  }
+}
+
 function resolvePackageRootDir(pkgName: string): string {
   try {
     const pkgJsonPath = requireFromZelune.resolve(`${pkgName}/package.json`);
@@ -33,98 +46,153 @@ const resolvedReactDomDir = resolvePackageRootDir('react-dom');
 const resolvedRnWebDir = resolvePackageRootDir('react-native-web');
 const resolvedLucideDir = resolvePackageRootDir('lucide-react');
 
-const PROTECTED_CORE_ALIASES = new Set([
-  'react',
-  'react-dom',
-  'react-native',
-  'react-native-web',
-  'lucide-react',
-  'lucide-react-native',
-  '@react-navigation/native',
-  'expo-router',
-  'react-native-safe-area-context',
-  'expo-status-bar',
-  '__proto__',
-  'constructor',
-  'prototype',
-]);
+/**
+ * Loads only safe client-public environment variables (EXPO_PUBLIC_*, NEXT_PUBLIC_*, VITE_*)
+ * from the target project's .env files so top-level SDK initializers in mobile screens work.
+ */
+function loadPublicProjectEnv(roots: string[]): Record<string, string> {
+  const publicEnv: Record<string, string> = {
+    NODE_ENV: 'development',
+    EXPO_PUBLIC_PLATFORM: 'web',
+  };
+  const envFiles = ['.env', '.env.development', '.env.local'];
+  const uniqueRoots = Array.from(new Set(roots.map((r) => path.resolve(r))));
 
-function stripJsonComments(input: string): string {
-  return input.replace(
-    /("(?:\\.|[^"\\])*")|\/\*[\s\S]*?\*\/|\/\/.*/g,
-    (_match, quotedString?: string) => quotedString ?? ''
-  );
-}
-
-function resolveTargetProjectPathAliases(projectRoot: string): Record<string, string> {
-  const normalizedRoot = path.resolve(projectRoot);
-  const aliases: Record<string, string> = {};
-  try {
-    const tsconfigPath = path.join(normalizedRoot, 'tsconfig.json');
-    if (fs.existsSync(tsconfigPath)) {
-      const raw = fs.readFileSync(tsconfigPath, 'utf-8');
-      const cleaned = stripJsonComments(raw);
-      const parsed = JSON.parse(cleaned) as {
-        compilerOptions?: {
-          baseUrl?: string;
-          paths?: Record<string, string[]>;
-        };
-      };
-      const baseUrl = parsed.compilerOptions?.baseUrl ?? '.';
-      const paths = parsed.compilerOptions?.paths ?? {};
-      for (const [pattern, targets] of Object.entries(paths)) {
-        if (!targets || targets.length === 0) continue;
-        const cleanKey = pattern.replace(/\/\*$/, '');
-        if (!cleanKey || PROTECTED_CORE_ALIASES.has(cleanKey)) continue;
-        const cleanTarget = targets[0].replace(/\/\*$/, '');
-        const resolvedTarget = path.resolve(normalizedRoot, baseUrl, cleanTarget);
-        if (
-          resolvedTarget === normalizedRoot ||
-          resolvedTarget.startsWith(normalizedRoot + path.sep)
-        ) {
-          aliases[cleanKey] = resolvedTarget;
+  for (const rootDir of uniqueRoots) {
+    for (const fileName of envFiles) {
+      const fullPath = path.join(rootDir, fileName);
+      try {
+        if (!fs.existsSync(fullPath)) continue;
+        const raw = fs.readFileSync(fullPath, 'utf-8');
+        for (const line of raw.split(/\r?\n/)) {
+          const trimmed = line.trim();
+          if (!trimmed || trimmed.startsWith('#')) continue;
+          const eqIdx = trimmed.indexOf('=');
+          if (eqIdx <= 0) continue;
+          const key = trimmed.slice(0, eqIdx).trim();
+          if (
+            !key.startsWith('EXPO_PUBLIC_') &&
+            !key.startsWith('NEXT_PUBLIC_') &&
+            !key.startsWith('VITE_')
+          ) {
+            continue;
+          }
+          let val = trimmed.slice(eqIdx + 1).trim();
+          if (
+            (val.startsWith('"') && val.endsWith('"')) ||
+            (val.startsWith("'") && val.endsWith("'"))
+          ) {
+            val = val.slice(1, -1);
+          }
+          publicEnv[key] = val;
         }
+      } catch {
+        // Ignore unreadable .env files
       }
     }
-  } catch {
-    // Ignore malformed tsconfig.json and fall back to standard @ alias below
   }
+  return publicEnv;
+}
 
-  if (!aliases['@']) {
-    const srcDir = path.join(normalizedRoot, 'src');
-    aliases['@'] = fs.existsSync(srcDir) ? srcDir : normalizedRoot;
-  }
+const publicProjectEnv = loadPublicProjectEnv([workspaceRoot, rawTargetRoot, targetProjectRoot]);
 
-  return aliases;
-}
+const allowedFsRoots = Array.from(
+  new Set([
+    __dirname,
+    safeRealpath(__dirname),
+    workspaceRoot,
+    safeRealpath(workspaceRoot),
+    rawTargetRoot,
+    safeRealpath(rawTargetRoot),
+    targetProjectRoot,
+    safeRealpath(targetProjectRoot),
+  ])
+);
 
 export default defineConfig({
   plugins: [
+    {
+      name: 'vite-zelune-process-env-shim',
+      transformIndexHtml(html) {
+        const serializedEnv = JSON.stringify(publicProjectEnv);
+        const envScript = `<script>
+(function() {
+  var baseEnv = ${serializedEnv};
+  var envProxy = new Proxy(baseEnv, {
+    get: function(target, prop) {
+      if (typeof prop !== 'string') return target[prop];
+      if (prop in target && target[prop] !== undefined && target[prop] !== '') {
+        return target[prop];
+      }
+      var upper = prop.toUpperCase();
+      if (upper.includes('URL') || upper.includes('ENDPOINT') || upper.includes('HOST')) {
+        return 'https://placeholder.example.com';
+      }
+      if (upper.includes('KEY') || upper.includes('TOKEN') || upper.includes('ID') || upper.includes('SECRET')) {
+        return 'placeholder-public-token';
+      }
+      return '';
+    }
+  });
+  function createRequireProxy() {
+    var fn = function() { return proxy; };
+    var proxy = new Proxy(fn, {
+      get: function(_t, prop) {
+        if (prop === Symbol.toPrimitive) return function(hint) { return hint === 'number' ? 0 : ''; };
+        if (prop === 'valueOf') return function() { return 0; };
+        if (prop === 'toString') return function() { return ''; };
+        if (prop === 'uri' || prop === 'default') return '';
+        return proxy;
+      }
+    });
+    return proxy;
+  }
+  window.global = window;
+  window.__DEV__ = true;
+  window.process = window.process || { env: envProxy, platform: 'browser', version: '', cwd: function() { return '/'; } };
+  window.process.env = envProxy;
+  window.require = window.require || function(modId) {
+    if (typeof modId === 'string' && /\\.(png|jpe?g|gif|webp|svg|avif|bmp)$/i.test(modId)) {
+      return { uri: modId, default: modId };
+    }
+    return createRequireProxy();
+  };
+})();
+</script>`;
+        return html.replace('<head>', `<head>\n    ${envScript}`);
+      },
+    },
+    viteReactNativeFallbackPlugin(targetProjectRoot, mockNavShimPath, workspaceRoot),
     viteVirtualScreensPlugin(targetProjectRoot),
     viteRnSourceInject(targetProjectRoot),
     react(),
     viteCanvasApiMiddleware(targetProjectRoot),
   ],
+  optimizeDeps: {
+    noDiscovery: true,
+    include: [
+      'react',
+      'react/jsx-runtime',
+      'react/jsx-dev-runtime',
+      'react-dom',
+      'react-dom/client',
+      'react-native-web',
+      'lucide-react',
+    ],
+  },
   esbuild: {
-    // Ensure .tsx/.ts/.jsx files are transpiled even when zelune is installed inside node_modules/zelune
-    include: /\.(tsx|ts|jsx)$/,
+    // Ensure .tsx/.ts/.jsx/.js files (including RN .js files with JSX) are transpiled cleanly
+    include: /\.(tsx|ts|jsx|js)$/,
     exclude: [],
     loader: 'tsx',
   },
   resolve: {
     dedupe: ['react', 'react-dom', 'react-native-web'],
     alias: {
-      ...resolveTargetProjectPathAliases(targetProjectRoot),
       react: resolvedReactDir,
       'react-dom': resolvedReactDomDir,
-      'react-native': resolvedRnWebDir,
       'react-native-web': resolvedRnWebDir,
       'lucide-react': resolvedLucideDir,
-      'lucide-react-native': resolvedLucideDir,
-      '@react-navigation/native': mockNavShimPath,
-      'expo-router': mockNavShimPath,
-      'react-native-safe-area-context': mockNavShimPath,
-      'expo-status-bar': mockNavShimPath,
     },
     extensions: ['.web.tsx', '.web.ts', '.web.js', '.tsx', '.ts', '.jsx', '.js'],
   },
@@ -142,7 +210,8 @@ export default defineConfig({
     cors: false,
     allowedHosts: ['127.0.0.1', 'localhost', '::1'],
     fs: {
-      allow: Array.from(new Set([__dirname, rawTargetRoot, targetProjectRoot])),
+      strict: false,
+      allow: allowedFsRoots,
     },
   },
 });