@keak/sdk 2.0.2 → 2.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@keak/sdk",
-  "version": "2.0.2",
+  "version": "2.0.3",
   "description": "Production-ready A/B testing and experimentation SDK for React applications with visual editing, source mapping, and real-time variant testing",
   "author": "Keak Team",
   "homepage": "https://www.keak.com/",

package/src/plugins/next.cjs

@@ -14,10 +14,13 @@ function withKeak(nextConfig = {}) {
   return {
     ...nextConfig,
     webpack(config, options) {
-      const { dev } = options;
+      const { dev, isServer } = options;
+
+      console.log('[Keak Plugin] webpack called - dev:', dev, 'isServer:', isServer);
 
       // Only inject loader in development mode
       if (!dev) {
+        console.log('[Keak Plugin] Skipping - not in development mode');
         // Call original webpack config if it exists
         if (typeof nextConfig.webpack === 'function') {
           return nextConfig.webpack(config, options);
@@ -30,6 +33,9 @@ function withKeak(nextConfig = {}) {
       const keakLoaderPath = fs.existsSync(projectKeakLoader)
         ? projectKeakLoader
         : path.resolve(__dirname, 'webpack-loader-babel/index.js');
+      
+      console.log('[Keak Plugin] Using loader path:', keakLoaderPath);
+      console.log('[Keak Plugin] Loader exists:', fs.existsSync(keakLoaderPath));
 
       // Ensure config.module.rules exists
       if (!config.module || !config.module.rules) {

package/src/plugins/webpack-loader-babel/index.js

@@ -1,16 +1,15 @@
 /**
- * Webpack loader that uses Babel to inject Keak source attributes into JSX
- * Simplified version - runs BEFORE SWC compilation
+ * Webpack loader that injects Keak source attributes into JSX
+ * 
+ * Uses regex-based injection instead of full Babel AST transformation
+ * to avoid interfering with React's module resolution in Next.js 15
+ * 
  * Only runs in development mode
  */
 
 const path = require('path');
-const babelParser = require('@babel/parser');
-const babelTraverse = require('@babel/traverse').default;
-const babelGenerator = require('@babel/generator').default;
-const t = require('@babel/types');
 
-module.exports = function keakLoaderBabel(source) {
+module.exports = function keakSourceLoader(source) {
   this.cacheable(true);
 
   const resourcePath = this.resourcePath;
@@ -22,101 +21,87 @@ module.exports = function keakLoaderBabel(source) {
   }
 
   // Skip if not a JSX/TSX file
-  if (!/\.(jsx|tsx|js|ts)$/.test(resourcePath)) {
+  if (!/\.(jsx|tsx)$/.test(resourcePath)) {
     return source;
   }
 
-  try {
-    // Parse the source code
-    const ast = babelParser.parse(source, {
-      sourceType: 'module',
-      plugins: [
-        'jsx',
-        'typescript',
-        'decorators-legacy',
-        'classProperties',
-        'objectRestSpread',
-        'dynamicImport',
-        'nullishCoalescingOperator',
-        'optionalChaining'
-      ]
-    });
+  // Skip node_modules
+  if (resourcePath.includes('node_modules')) {
+    return source;
+  }
+
+  // Skip files that use next/font (known to conflict with Babel processing)
+  if (source.includes('next/font') || source.includes('@next/font')) {
+    return source;
+  }
 
-    let skipFile = false;
+  // Skip if already processed
+  if (source.includes('data-keak-src=')) {
+    return source;
+  }
 
-    // Check for next/font imports (Babel/SWC conflict)
-    babelTraverse(ast, {
-      ImportDeclaration(importPath) {
-        const source = importPath.node.source.value;
-        if (source.includes('next/font') || source.includes('@next/font')) {
-          skipFile = true;
-          importPath.stop();
+  try {
+    // Smart relative path detection
+    let sourceFile;
+    const srcParts = resourcePath.split('/src/');
+    if (srcParts.length > 1) {
+      sourceFile = 'src/' + srcParts[srcParts.length - 1];
+    } else {
+      const appParts = resourcePath.split('/app/');
+      if (appParts.length > 1) {
+        sourceFile = 'app/' + appParts[appParts.length - 1];
+      } else {
+        const compParts = resourcePath.split('/components/');
+        if (compParts.length > 1) {
+          sourceFile = 'components/' + compParts[compParts.length - 1];
+        } else {
+          sourceFile = path.relative(process.cwd(), resourcePath);
         }
       }
-    });
-
-    if (skipFile) {
-      return source;
     }
 
-    // Transform JSX elements
-    babelTraverse(ast, {
-      JSXOpeningElement(nodePath) {
-        const node = nodePath.node;
-
-        // Skip if already has keak attributes
-        const hasKeakAttr = node.attributes.some(attr =>
-          t.isJSXAttribute(attr) &&
-          t.isJSXIdentifier(attr.name) &&
-          (attr.name.name === 'data-keak-file' || attr.name.name === 'data-keak-src')
-        );
-
-        if (hasKeakAttr || !node.loc) {
-          return;
-        }
-
-        // Smart relative path detection
-        let sourceFile;
-        const srcParts = resourcePath.split('/src/');
-        if (srcParts.length > 1) {
-          sourceFile = 'src/' + srcParts[srcParts.length - 1];
-        } else {
-          const appParts = resourcePath.split('/app/');
-          if (appParts.length > 1) {
-            sourceFile = 'app/' + appParts[appParts.length - 1];
+    // Track the current line number
+    const lines = source.split('\n');
+    const processedLines = [];
+    
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const lineNumber = i + 1;
+      
+      // Match JSX opening tags: <ComponentName or <div, etc.
+      // But not self-closing tags that are already complete, or fragments
+      const processedLine = line.replace(
+        // Match: <TagName followed by space, newline, or >
+        // But NOT: </tag, <>, <Fragment
+        /<([A-Z][a-zA-Z0-9]*|[a-z][a-zA-Z0-9-]*)(\s|>)/g,
+        (match, tagName, after) => {
+          // Skip fragments and closing tags
+          if (tagName === 'Fragment' || tagName === '') {
+            return match;
+          }
+          
+          // Skip if this looks like it already has data-keak attributes
+          if (line.includes('data-keak-')) {
+            return match;
+          }
+          
+          // Inject the attribute
+          const attr = ` data-keak-src="${sourceFile}:${lineNumber}:1"`;
+          
+          if (after === '>') {
+            // <tag> -> <tag data-keak-src="...">
+            return `<${tagName}${attr}>`;
           } else {
-            const compParts = resourcePath.split('/components/');
-            if (compParts.length > 1) {
-              sourceFile = 'components/' + compParts[compParts.length - 1];
-            } else {
-              sourceFile = path.relative(process.cwd(), resourcePath);
-            }
+            // <tag  -> <tag data-keak-src="..." 
+            return `<${tagName}${attr}${after}`;
           }
         }
+      );
+      
+      processedLines.push(processedLine);
+    }
 
-        const { line } = node.loc.start;
-
-        // Add data-keak-file and data-keak-line attributes
-        node.attributes.push(
-          t.jsxAttribute(
-            t.jsxIdentifier('data-keak-file'),
-            t.stringLiteral(sourceFile)
-          ),
-          t.jsxAttribute(
-            t.jsxIdentifier('data-keak-line'),
-            t.stringLiteral(String(line))
-          )
-        );
-      }
-    });
-
-    // Generate transformed code
-    const output = babelGenerator(ast, {
-      retainLines: false,
-      compact: false
-    }, source);
-
-    return output.code;
+    return processedLines.join('\n');
   } catch (error) {
     // Return original source on error
     console.error(`[keak-loader] Error processing ${resourcePath}:`, error.message);