@rws-framework/client 2.18.5 → 2.18.7

package/builder/webpack/scss/_import.js

@@ -26,8 +26,8 @@ function processImportPath(importPath, rwsWorkspaceDir, appRootDir, fileRootDir
         return fillSCSSExt(path.join(this.appRootDir, importPath.slice(4)), noext);
     }
 
-    if (importPath.split('')[0] === '/') {
-        const originalImport = fillSCSSExt(importPath, noext);
+    if (importPath.split('')[0] === '/' || importPath.split('')[1] === ':') {
+        const originalImport = fillSCSSExt(importPath, noext);        
         
         if(!fs.existsSync(originalImport)){
             const absoluteImport = fillSCSSExt(path.join(workspaceDir, 'src', importPath), noext);

package/cfg/build_steps/webpack/_cache.js

@@ -21,7 +21,7 @@ class RWSCacheSystem {
 
         if(!this.enabled){            
             if(fs.existsSync(this.rwsDir+'/front')){
-                console.log({pat: this.rwsDir+'/front'});
+                // console.log({pat: this.rwsDir+'/front'});
                 rmdir(this.rwsDir+'/front', { recursive: true });
                 console.log(chalk.red('[RWS CACHE] front cache removed.'));
             }

package/cfg/build_steps/webpack/_hot_reload.js

@@ -1,14 +1,14 @@
-function getRWSHotReloadSetup(port, outputDir){
-    return {
-        hot: true,
-        port,
-        static: {
-            directory: outputDir,            
-        },
-        devMiddleware: {
-            publicPath: '/'
-        }
-    }
-}
-
+function getRWSHotReloadSetup(port, outputDir){
+    return {
+        hot: true,
+        port,
+        static: {
+            directory: outputDir,            
+        },
+        devMiddleware: {
+            publicPath: '/'
+        }
+    }
+}
+
 module.exports = { getRWSHotReloadSetup };

package/cfg/build_steps/webpack/_info.js

@@ -17,10 +17,10 @@ module.exports = {
         plugins: rwsPlugins
         });
 
-        console.log(chalk.blue('\nTSCONFIG:'), util.inspect(tsConfig.config, {
-            depth: null,
-            colors: true,
-            maxArrayLength: null
-        }));
+        // console.log(chalk.blue('\nTSCONFIG:'), util.inspect(tsConfig.config, {
+        //     depth: null,
+        //     colors: true,
+        //     maxArrayLength: null
+        // }));
     }
 }

package/cfg/build_steps/webpack/_loaders.js

@@ -71,6 +71,7 @@ function getRWSLoaders(packageDir, executionDir, tsConfigData, appRootDir, entry
       ],
       exclude: [
         ...tsConfigData.excludes.map(item => item.abs()),
+        path.resolve(packageDir, 'builder'),            
         /\.debug\.ts$/,
         /\.d\.ts$/        
       ]     
@@ -87,9 +88,7 @@ function getRWSLoaders(packageDir, executionDir, tsConfigData, appRootDir, entry
         },
       ],
     },
-  ];
-
-  console.log(loaders[2].include);
+  ];  
 
   return loaders;
 }

package/cfg/build_steps/webpack/_parser.js

@@ -1,118 +1,118 @@
-// _parser.js
-const path = require('path');
-const fs = require('fs');
-
-function checkIfPackageIsLinked(basePath, packageName) {
-    try {
-        // Check package.json first
-        const packageJsonPath = path.join(basePath, 'package.json');
-        if (fs.existsSync(packageJsonPath)) {
-            const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
-            
-            // Check if it's in dependencies or devDependencies
-            const version = packageJson.dependencies?.[packageName] || packageJson.devDependencies?.[packageName];
-            
-            // If version starts with 'file:' or 'link:', it's linked
-            if (version && (version.startsWith('file:') || version.startsWith('link:'))) {
-                return {
-                    isLinked: true,
-                    source: 'package.json',
-                    linkPath: version.replace(/^(file:|link:)/, '')
-                };
-            }
-        }
-
-        // Check yarn.lock
-        const yarnLockPath = path.join(basePath, 'yarn.lock');
-        if (fs.existsSync(yarnLockPath)) {
-            const yarnLockContent = fs.readFileSync(yarnLockPath, 'utf8');
-            const packageEntry = yarnLockContent.split('\n\n').find(entry => 
-                entry.includes(`"${packageName}@`)
-            );
-            
-            if (packageEntry && packageEntry.includes('link:')) {
-                const linkMatch = packageEntry.match(/link: (.+)/);
-                return {
-                    isLinked: true,
-                    source: 'yarn.lock',
-                    linkPath: linkMatch ? linkMatch[1] : null
-                };
-            }
-        }
-
-        // Check package-lock.json
-        const packageLockPath = path.join(basePath, 'package-lock.json');
-        if (fs.existsSync(packageLockPath)) {
-            const packageLock = JSON.parse(fs.readFileSync(packageLockPath, 'utf8'));
-            const packageInfo = packageLock.dependencies?.[packageName] || 
-                              packageLock.devDependencies?.[packageName];
-            
-            if (packageInfo && packageInfo.link) {
-                return {
-                    isLinked: true,
-                    source: 'package-lock.json',
-                    linkPath: packageInfo.link
-                };
-            }
-        }
-
-        return {
-            isLinked: false,
-            source: null,
-            linkPath: null
-        };
-    } catch (e) {
-        console.error('Error checking package link status:', e);
-        return {
-            isLinked: false,
-            source: null,
-            linkPath: null,
-            error: e.message
-        };
-    }
-}
-
-function parseWebpackPath(stack) {
-    const currentFileLine = stack.split('\n').find(line => line.includes('_loaders.js'));
-    if (!currentFileLine) return null;
-
-    const match = currentFileLine.match(/\((.+?):\d+:\d+\)/);
-    if (!match) return null;
-
-    const originalPath = match[1];
-    
-    if (originalPath.includes('webpack:')) {
-        const [fsPath, webpackPath] = originalPath.split('webpack:');
-        const basePath = fsPath.replace('/build/', '/');
-        
-        // Check if @rws-framework/client is linked
-        const linkInfo = checkIfPackageIsLinked(basePath, '@rws-framework/client');
-
-        // Check both possible locations
-        const possiblePaths = [
-            // Check in @dev/client
-            path.join(basePath, '../@dev/client', webpackPath),
-            // Check in node_modules
-            path.join(basePath, 'node_modules/@rws-framework/client', webpackPath.replace('/client/', '/'))
-        ];
-
-        for (const possiblePath of possiblePaths) {
-            if (fs.existsSync(possiblePath)) {
-                return {
-                    original: originalPath,
-                    fsPath: basePath,
-                    webpackPath,
-                    exists: true,
-                    realPath: fs.realpathSync(possiblePath),
-                    resolvedPath: possiblePath,
-                    location: possiblePath.includes('node_modules') ? 'node_modules' : '@dev',
-                    linkInfo // Include the link information
-                };
-            }
-        }
-    }
-
-    return null;
-}
-
+// _parser.js
+const path = require('path');
+const fs = require('fs');
+
+function checkIfPackageIsLinked(basePath, packageName) {
+    try {
+        // Check package.json first
+        const packageJsonPath = path.join(basePath, 'package.json');
+        if (fs.existsSync(packageJsonPath)) {
+            const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+            
+            // Check if it's in dependencies or devDependencies
+            const version = packageJson.dependencies?.[packageName] || packageJson.devDependencies?.[packageName];
+            
+            // If version starts with 'file:' or 'link:', it's linked
+            if (version && (version.startsWith('file:') || version.startsWith('link:'))) {
+                return {
+                    isLinked: true,
+                    source: 'package.json',
+                    linkPath: version.replace(/^(file:|link:)/, '')
+                };
+            }
+        }
+
+        // Check yarn.lock
+        const yarnLockPath = path.join(basePath, 'yarn.lock');
+        if (fs.existsSync(yarnLockPath)) {
+            const yarnLockContent = fs.readFileSync(yarnLockPath, 'utf8');
+            const packageEntry = yarnLockContent.split('\n\n').find(entry => 
+                entry.includes(`"${packageName}@`)
+            );
+            
+            if (packageEntry && packageEntry.includes('link:')) {
+                const linkMatch = packageEntry.match(/link: (.+)/);
+                return {
+                    isLinked: true,
+                    source: 'yarn.lock',
+                    linkPath: linkMatch ? linkMatch[1] : null
+                };
+            }
+        }
+
+        // Check package-lock.json
+        const packageLockPath = path.join(basePath, 'package-lock.json');
+        if (fs.existsSync(packageLockPath)) {
+            const packageLock = JSON.parse(fs.readFileSync(packageLockPath, 'utf8'));
+            const packageInfo = packageLock.dependencies?.[packageName] || 
+                              packageLock.devDependencies?.[packageName];
+            
+            if (packageInfo && packageInfo.link) {
+                return {
+                    isLinked: true,
+                    source: 'package-lock.json',
+                    linkPath: packageInfo.link
+                };
+            }
+        }
+
+        return {
+            isLinked: false,
+            source: null,
+            linkPath: null
+        };
+    } catch (e) {
+        console.error('Error checking package link status:', e);
+        return {
+            isLinked: false,
+            source: null,
+            linkPath: null,
+            error: e.message
+        };
+    }
+}
+
+function parseWebpackPath(stack) {
+    const currentFileLine = stack.split('\n').find(line => line.includes('_loaders.js'));
+    if (!currentFileLine) return null;
+
+    const match = currentFileLine.match(/\((.+?):\d+:\d+\)/);
+    if (!match) return null;
+
+    const originalPath = match[1];
+    
+    if (originalPath.includes('webpack:')) {
+        const [fsPath, webpackPath] = originalPath.split('webpack:');
+        const basePath = fsPath.replace('/build/', '/');
+        
+        // Check if @rws-framework/client is linked
+        const linkInfo = checkIfPackageIsLinked(basePath, '@rws-framework/client');
+
+        // Check both possible locations
+        const possiblePaths = [
+            // Check in @dev/client
+            path.join(basePath, '../@dev/client', webpackPath),
+            // Check in node_modules
+            path.join(basePath, 'node_modules/@rws-framework/client', webpackPath.replace('/client/', '/'))
+        ];
+
+        for (const possiblePath of possiblePaths) {
+            if (fs.existsSync(possiblePath)) {
+                return {
+                    original: originalPath,
+                    fsPath: basePath,
+                    webpackPath,
+                    exists: true,
+                    realPath: fs.realpathSync(possiblePath),
+                    resolvedPath: possiblePath,
+                    location: possiblePath.includes('node_modules') ? 'node_modules' : '@dev',
+                    linkInfo // Include the link information
+                };
+            }
+        }
+    }
+
+    return null;
+}
+
 module.exports = { parseWebpackPath, checkIfPackageIsLinked };

package/cfg/build_steps/webpack/_rws_externals.js

@@ -37,8 +37,6 @@ const externals = (declaredCodeBase, nodeModules, automatedChunks, externalOptio
       path.resolve(__dirname,'..','..','..')
     ];        
 
-    console.log({frontendDirs})
-
     const inFrontendContext = frontendDirs.some(dir => context.startsWith(dir)) || 
         externalOptions._vars.frontendRequestContextCache.some(package => context.indexOf(package.request) > -1)
     

package/cfg/tsconfigSetup.js

@@ -96,8 +96,7 @@ function setupTsConfig(tsConfigPath, executionDir, pkgPath, userAliases = {}) {
                 }
             });
 
-            if(changedPaths){
-                console.log('tspaths', tsPaths);
+            if(changedPaths){                
                 console.log(chalk.blueBright('[RWS TS CONFIG]'), 'adding user aliases as paths to project tsconfig.json');
 
                 tsConfig.compilerOptions.paths = tsPaths;