@rws-framework/client 2.10.8 → 2.10.10

package/_tools.js

@@ -5,6 +5,9 @@ const { spawn } = require('child_process');
 const JSON5 = require('json5');
 
 const { setupTsConfig } = require('./cfg/tsconfigSetup');
+const LoadersHelper = require('./cfg/build_steps/webpack/_loaders');
+
+const { rwsPath } = require('@rws-framework/console');
 
 function findRootWorkspacePath(currentPath) {
   const parentPackageJsonPath = path.join(currentPath + '/..', 'package.json');
@@ -165,16 +168,17 @@ function findComponentFilesWithText(dir, text, ignored = [], fileList = []) {
 
     if (fileStat.isDirectory() && !ignored.includes(file)) {
       findComponentFilesWithText(filePath, text, ignored, fileList);
-    } else if (fileStat.isFile() && filePath.endsWith('.ts')) {
+    } else if (fileStat.isFile() && filePath.endsWith('component.ts')) {
       const content = fs.readFileSync(filePath, 'utf8');
       if (content.includes(text)) {        
-        const compInfo = extractComponentInfo(content);        
+        try {
+        const compInfo = extractComponentInfo(content);  
 
         if (compInfo) {
       
-          const { tagName, className, options, isIgnored, isOreo } = compInfo;
+          const { tagName, className, options } = compInfo;
 
-          if (isIgnored) {
+          if (options?.ignorePackaging) {
             return;
           }
 
@@ -188,6 +192,11 @@ function findComponentFilesWithText(dir, text, ignored = [], fileList = []) {
             isIgnored: options?.ignorePackaging,
             isOreo: options?.oreoMode
           });
+          
+        }
+        }catch(e){
+          console.log('ERRORER', e);
+          throw new Error(`findComponentFilesWithText('${dir}', '${text}') error`)
         }
       }
     }
@@ -196,6 +205,7 @@ function findComponentFilesWithText(dir, text, ignored = [], fileList = []) {
   return fileList;
 }
 
+
 function extractRWSViewArguments(sourceFile) {
   let argumentsExtracted = {
     className: null,
@@ -292,23 +302,18 @@ function extractRWSIgnoreArguments(sourceFile) {
 }
 
 function extractComponentInfo(componentCode) {
-  const componentNameRegex = /@RWSView/;
-
-  if (!componentNameRegex.test(componentCode)) {
-    return;
-  }
+  const decoratorData = LoadersHelper.extractRWSViewArgs(componentCode, true);
 
-  const tsSourceFile = ts.createSourceFile(`/tmp/temp_ts`, componentCode, ts.ScriptTarget.Latest, true);  
-
-  let decoratorArgs = extractRWSViewArguments(tsSourceFile);
-
-  if (!decoratorArgs) {
-    decoratorArgs = {};
+  if(!decoratorData){
+    return null;
   }
+  // console.log(decoratorData, componentCode);
 
-  decoratorOpts = decoratorArgs.options;
-
-  return { ...decoratorArgs, options: decoratorOpts };
+  return { 
+    tagName: decoratorData.viewDecoratorData.tagName, 
+    className: decoratorData.viewDecoratorData.className, 
+    options: decoratorData.viewDecoratorData.decoratorArgs
+  };
 }
 
 function getAllFilesInFolder(folderPath, ignoreFilenames = [], recursive = false) {

package/cfg/build_steps/webpack/_actions.js

@@ -0,0 +1,86 @@
+const chalk = require('chalk');
+
+const { rwsRuntimeHelper } = require('@rws-framework/console');
+
+
+function executeRWSStartActions(WEBPACK_AFTER_ACTIONS, serviceWorkerPath, BuildConfigurator, rwsFrontConfig) {
+    if (serviceWorkerPath) {
+        WEBPACK_AFTER_ACTIONS.push({
+            type: 'service_worker',
+            actionHandler: serviceWorkerPath
+        });
+    }
+
+    const assetsToCopy = BuildConfigurator.get('copyAssets') || rwsFrontConfig.copyAssets;
+
+    if (!!assetsToCopy) {
+        WEBPACK_AFTER_ACTIONS.push({
+            type: 'copy',
+            actionHandler: assetsToCopy
+        });
+    }
+}
+
+
+function timingActions(WEBPACK_AFTER_ACTIONS, WEBPACK_AFTER_ERROR_ACTIONS, devDebug){
+    if(devDebug?.timing){
+        rwsRuntimeHelper.setRWSVar('_timer_css', 'none|0');
+    
+        WEBPACK_AFTER_ACTIONS.push({
+          type: 'custom',
+          actionHandler: () => {  
+            
+            const cssTimesList = rwsRuntimeHelper.getRWSVar('_timer_css');        
+            
+            if(cssTimesList){
+              const cssTime = cssTimesList.split('\n').map((elString) => {
+                const item = elString.split('|')[1];
+                return item === '' ? 0 : parseInt(item)
+              }).reduce((acc, curr) => acc + curr, 0);
+              rwsRuntimeHelper.setRWSVar('_timer_css', 'none|0');                 
+              console.log(chalk.yellow('[RWS BUILD] (after)'), `CSS TIME: ${Math.round(cssTime)}`);
+    
+            }
+          }
+        });
+      }
+    
+      WEBPACK_AFTER_ERROR_ACTIONS.push({
+        type: 'custom',
+        actionHandler: () => {
+          console.log('CUSTOM ERROR');
+          rwsRuntimeHelper.setRWSVar('_timer_css', 'none|0');
+        }
+      });
+}
+
+function devActions(WEBPACK_AFTER_ACTIONS, executionDir, devDebug){
+    const devExternalsVars = {
+        packed: [],
+        ignored: [],
+        frontendRequestContextCache: []
+      }
+    
+      if(devDebug?.build){
+        const debugDir = path.join(executionDir, '.debug');
+    
+        if(!fs.existsSync(debugDir)){
+          fs.mkdirSync(debugDir)
+        }
+    
+        WEBPACK_AFTER_ACTIONS.push({
+          type: 'custom',
+          actionHandler: () => {        
+            fs.writeFile(path.join(debugDir, 'in_vendors.json'), JSON.stringify(devExternalsVars.ignored, null, 2));
+            fs.writeFile(path.join(debugDir, 'rws_processed.json'), JSON.stringify(devExternalsVars.packed, null, 2));
+            fs.writeFile(path.join(debugDir, 'requestcache.json'), JSON.stringify(devExternalsVars.frontendRequestContextCache, null, 2));
+    
+            console.log(chalk.yellow('[RWS BUILD] (after)'), `packaging debug saved in: ${debugDir}`);
+          }
+        });
+      }
+
+      return devExternalsVars;
+}
+
+module.exports = { devActions, timingActions, executeRWSStartActions }

package/cfg/build_steps/webpack/_aliases.js

@@ -1,8 +1,8 @@
 const path = require('path');
 
-function loadAliases(packageDir, nodeModulesPath){
+function loadAliases(packageDir, nodeModulesPath, srcDir){    
     return {
-        fs: false,
+        'src': srcDir + '/src',        
         '@rws-framework/foundation': path.resolve(packageDir, 'foundation', 'rws-foundation.js')
     }
 }

package/cfg/build_steps/webpack/_build_config.js

@@ -0,0 +1,77 @@
+const chalk = require('chalk');
+const { RWSConfigBuilder } = require('@rws-framework/console')
+const { rwsPath } = require('@rws-framework/console');
+const { _DEFAULT_CONFIG } = require('../../_default.cfg');
+
+async function getBuildConfig(rwsFrontBuildConfig){
+    const BuildConfigurator = new RWSConfigBuilder(rwsPath.findPackageDir(process.cwd()) + '/.rws.json', {..._DEFAULT_CONFIG, ...rwsFrontBuildConfig});
+    const _packageDir = rwsPath.findPackageDir(process.cwd());
+
+    const executionDir = rwsPath.relativize(BuildConfigurator.get('executionDir') || rwsFrontBuildConfig.executionDir || process.cwd(), _packageDir);
+    const isWatcher = process.argv.includes('--watch') || false;  
+
+    const isDev = isWatcher ? true : (BuildConfigurator.get('dev', rwsFrontBuildConfig.dev) || false);
+    const isHotReload = BuildConfigurator.get('hot', rwsFrontBuildConfig.hot);
+    const isReport = BuildConfigurator.get('report', rwsFrontBuildConfig.report);
+    const isParted = BuildConfigurator.get('parted', rwsFrontBuildConfig.parted || false);
+
+    const partedPrefix = BuildConfigurator.get('partedPrefix', rwsFrontBuildConfig.partedPrefix);
+    const partedDirUrlPrefix = BuildConfigurator.get('partedDirUrlPrefix', rwsFrontBuildConfig.partedDirUrlPrefix);
+
+    let partedComponentsLocations = BuildConfigurator.get('partedComponentsLocations', rwsFrontBuildConfig.partedComponentsLocations);
+    const customServiceLocations = BuildConfigurator.get('customServiceLocations', rwsFrontBuildConfig.customServiceLocations); //@todo: check if needed
+    const outputDir = rwsPath.relativize(BuildConfigurator.get('outputDir', rwsFrontBuildConfig.outputDir), _packageDir);
+
+    const outputFileName = BuildConfigurator.get('outputFileName') || rwsFrontBuildConfig.outputFileName;
+    const publicDir = BuildConfigurator.get('publicDir') || rwsFrontBuildConfig.publicDir;
+    const serviceWorkerPath = BuildConfigurator.get('serviceWorker') || rwsFrontBuildConfig.serviceWorker;
+
+    const publicIndex = BuildConfigurator.get('publicIndex') || rwsFrontBuildConfig.publicIndex;
+
+    const devTools = isDev ? (BuildConfigurator.get('devtool') || 'source-map') : false;
+
+    const _DEFAULT_DEV_DEBUG = { build: false, timing: false, rwsCache: false, profiling: false };
+
+    let devDebug = isDev ? (BuildConfigurator.get('devDebug') || rwsFrontBuildConfig.devDebug || {}) : {};
+    devDebug = {..._DEFAULT_DEV_DEBUG, ...devDebug}
+
+    const devRouteProxy = BuildConfigurator.get('devRouteProxy') || rwsFrontBuildConfig.devRouteProxy;
+
+    const tsConfigPath = rwsPath.relativize(BuildConfigurator.get('tsConfigPath') || rwsFrontBuildConfig.tsConfigPath, executionDir);
+
+    const rwsPlugins = {};
+
+    if(rwsFrontBuildConfig.rwsPlugins){
+        for(const pluginEntry of rwsFrontBuildConfig.rwsPlugins){
+          const pluginBuilder = (await import(`${pluginEntry}/build.js`)).default;      
+          rwsPlugins[pluginEntry] = new pluginBuilder(BuildConfigurator, rwsFrontBuildConfig);
+        }
+      }
+
+    return {
+        executionDir,
+        isWatcher,
+        isDev,
+        isHotReload,
+        isReport,
+        isParted,
+        partedPrefix,
+        partedDirUrlPrefix,
+        partedComponentsLocations,
+        customServiceLocations,
+        outputDir,
+        outputFileName,
+        publicDir,
+        serviceWorkerPath,
+        publicIndex,
+        devTools,
+        devDebug,
+        devRouteProxy,
+        tsConfigPath,
+        rwsPlugins,
+        _packageDir,
+        BuildConfigurator
+    }
+}
+
+module.exports = { getBuildConfig }

package/cfg/build_steps/webpack/_cache.js

@@ -0,0 +1,99 @@
+const { rwsPath, rwsRuntimeHelper } = require('@rws-framework/console');
+
+const fs = require('fs');
+const path = require('path');
+const md5 = require('md5');
+const chalk = require('chalk');
+const { rmdir } = require('fs/promises');
+
+class RWSCacheSystem {        
+    constructor(customCompilationOptions){        
+        const WORKSPACE = rwsPath.findRootWorkspacePath(process.cwd());
+        this.rwsDir = path.resolve(WORKSPACE, 'node_modules', '.rws');
+
+        this.customCompilationOptions = customCompilationOptions;
+
+        if(!fs.existsSync(this.rwsDir)){
+            fs.mkdirSync(this.rwsDir);
+        }
+
+        this.enabled = this.customCompilationOptions ? (this.customCompilationOptions?.devDebug?.rwsCache) === true : false;
+
+        if(!this.enabled){            
+            if(fs.existsSync(this.rwsDir+'/front')){
+                console.log({pat: this.rwsDir+'/front'});
+                rmdir(this.rwsDir+'/front', { recursive: true });
+                console.log(chalk.red('[RWS CACHE] front cache removed.'));
+            }
+        }
+    }
+
+    hasCachedItem(filePath){
+        return this.enabled ? rwsRuntimeHelper.getRWSVar(this.getCacheKey(filePath)) !== null : false;
+    }
+    
+    getCachedItem(filePath, fileHash = null){
+        if(!this.enabled){
+            return null;
+        }
+
+        const key = this.getCacheKey(filePath);
+        const item = rwsRuntimeHelper.getRWSVar(key);
+        let itemCfg = rwsRuntimeHelper.getRWSVar(key + '.cfg.json');
+    
+        if(itemCfg){
+            itemCfg = JSON.parse(itemCfg);
+        } 
+    
+        if(item){
+            if((!itemCfg || !fileHash) || itemCfg.sourceHash !== fileHash){            
+                return null;
+            }
+    
+            return item;
+        }else{
+        return null;
+        }
+    }
+    
+    cacheItem(filePath, processedContent, sourceContent){  
+        if(!this.enabled){
+            return null;
+        }
+
+        const key = this.getCacheKey(filePath);
+    
+        rwsRuntimeHelper.setRWSVar(key, processedContent);
+        rwsRuntimeHelper.setRWSVar(key + '.cfg.json', JSON.stringify({
+            sourceHash: md5(sourceContent),
+            sourceFileName: filePath
+        }));
+    }
+    
+    removeCacheItem(filePath){
+        if(!this.enabled){
+            return null;
+        }
+
+        rwsRuntimeHelper.removeRWSVar(this.getCacheKey(filePath));
+        rwsRuntimeHelper.removeRWSVar(this.getCacheKey(filePath) + '.cfg.json');
+    }
+    
+    getCacheKey(filePath){
+        return `front/${md5(filePath)}`;
+    }
+}
+
+const RWSCache = {
+    _instance: null,
+    cache: (customCompilationOptions) => {
+        
+        if(!this._instance){
+            this._instance = new RWSCacheSystem(customCompilationOptions);
+        }
+
+        return this._instance;
+    }
+}
+
+module.exports = RWSCache;

package/cfg/build_steps/webpack/_component_handling.js

@@ -0,0 +1,61 @@
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs');
+const tools = require('../../../_tools');
+
+function scanComponents(partedComponentsLocations, executionDir, pkgCodeDir) {
+    const foundRWSUserClasses = tools.findComponentFilesWithText(executionDir, '@RWSView', ['dist', 'node_modules', '@rws-framework/client']);
+    const foundRWSClientClasses = tools.findComponentFilesWithText(pkgCodeDir, '@RWSView', ['dist', 'node_modules']);
+    let RWSComponents = [...foundRWSUserClasses, ...foundRWSClientClasses];
+
+    if (partedComponentsLocations) {
+        partedComponentsLocations.forEach((componentDir) => {
+            RWSComponents = [...RWSComponents, ...(tools.findComponentFilesWithText(path.resolve(componentDir), '@RWSView', ['dist', 'node_modules', '@rws-framework/client']))];
+        });
+    }
+
+    return RWSComponents;
+}
+
+function setComponentsChunks(clientEntry, RWSComponents = [], isParted = false) {
+    let automatedChunks = {
+        client: clientEntry,
+    };
+    const automatedEntries = {};
+    RWSComponents.forEach((fileInfo) => {
+        const isIgnored = fileInfo.isIgnored;
+
+        if (isIgnored === true) {
+            // console.warn('Ignored: '+ fileInfo.filePath);
+            return;
+        }
+
+        automatedEntries[fileInfo.tagName] = fileInfo.filePath;
+
+        if (isParted) {
+            automatedChunks[fileInfo.tagName] = fileInfo.filePath;
+        }
+    });
+
+    return { automatedChunks, automatedEntries }
+}
+
+function generateRWSInfoFile(outputDir, automatedEntries) {
+    const rwsInfoJson = outputDir + '/rws_info.json'
+    fs.writeFile(rwsInfoJson, JSON.stringify({ components: Object.keys(automatedEntries) }, null, 2), () => {});
+}
+
+async function partedComponentsEvents(partedComponentsLocations, rwsPlugins, isParted) {
+    if(!isParted){
+        return partedComponentsLocations;
+    }
+
+    for (const pluginKey of Object.keys(rwsPlugins)) {
+        const plugin = rwsPlugins[pluginKey];
+        partedComponentsLocations = await plugin.onComponentsLocated(partedComponentsLocations);
+    }
+
+    return partedComponentsLocations;
+}
+
+module.exports = { scanComponents, setComponentsChunks, generateRWSInfoFile, partedComponentsEvents }

package/cfg/build_steps/webpack/_dev_servers.js

@@ -0,0 +1,15 @@
+
+
+function webpackDevServer(BuildConfigurator, rwsFrontendConfig, cfgExport){
+    const backendUrl = BuildConfigurator.get('backendUrl') || rwsFrontendConfig.backendUrl;
+    const apiPort = BuildConfigurator.get('apiPort') || rwsFrontendConfig.apiPort;
+    
+    if (backendUrl && apiPort) {
+        // cfgExport.devServer = {
+        //   hot: true, // Enable hot module replacement
+        //   open: true, // Automatically open the browser
+        // }
+    }
+}
+
+module.exports = { webpackDevServer }

package/cfg/build_steps/webpack/_env_defines.js

@@ -0,0 +1,19 @@
+
+
+function processEnvDefines(BuildConfigurator, config, devDebug) {
+    let _rws_defines = {
+        'process.env._RWS_DEV_DEBUG': JSON.stringify(devDebug),
+        'process.env._RWS_DEFAULTS': JSON.stringify(BuildConfigurator.exportDefaultConfig()),
+        'process.env._RWS_BUILD_OVERRIDE': JSON.stringify(BuildConfigurator.exportBuildConfig())
+    }
+
+    const rwsDefines = BuildConfigurator.get('rwsDefines') || config.rwsDefines || null;
+
+    if (rwsDefines) {
+        _rws_defines = { ..._rws_defines, ...rwsDefines }
+    }
+
+    return _rws_defines;
+}
+
+module.exports = { processEnvDefines }