@rws-framework/client 2.5.4 → 2.6.0

package/_tools.js

@@ -7,8 +7,8 @@ const md5 = require('md5');
 const chalk = require('chalk');
 const { rwsPath } = require('@rws-framework/console');
 
-function findRootWorkspacePath(currentPath) {        
-  const parentPackageJsonPath = path.join(currentPath + '/..', 'package.json');        
+function findRootWorkspacePath(currentPath) {
+  const parentPackageJsonPath = path.join(currentPath + '/..', 'package.json');
   const parentPackageDir = path.dirname(parentPackageJsonPath);
 
   if (fs.existsSync(parentPackageJsonPath)) {
@@ -22,22 +22,21 @@ function findRootWorkspacePath(currentPath) {
   return currentPath;
 }
 
-function findPackageDir()
-{
+function findPackageDir() {
   return path.resolve(path.dirname(module.id));
 }
 
-function getActiveWorkSpaces(currentPath, mode = 'all') { 
-  if(!currentPath){
+function getActiveWorkSpaces(currentPath, mode = 'all') {
+  if (!currentPath) {
     throw new Error(`[_tools.js:getActiveWorkSpaces] "currentPath" argument is required.`);
   }
 
-  if(!(['all', 'frontend', 'backend'].includes(mode))){
+  if (!(['all', 'frontend', 'backend'].includes(mode))) {
     throw new Error(`[_tools.js:getActiveWorkSpaces] "mode" argument can be only: "frontend", "backend" or "all".`);
   }
 
   const rootPkgDir = findRootWorkspacePath(currentPath)
-  const parentPackageJsonPath = path.join(rootPkgDir, 'package.json');        
+  const parentPackageJsonPath = path.join(rootPkgDir, 'package.json');
   const parentPackageDir = path.dirname(parentPackageJsonPath);
 
   if (fs.existsSync(parentPackageJsonPath)) {
@@ -45,19 +44,19 @@ function getActiveWorkSpaces(currentPath, mode = 'all') {
 
     if (packageJson.workspaces) {
       return packageJson.workspaces.map((workspaceName) => path.join(rootPkgDir, workspaceName)).filter((workspaceDir) => {
-        if(mode === 'all'){
+        if (mode === 'all') {
           return true;
         }
 
         let rwsPkgName = '@rws-framework/server';
 
-        if(mode === 'frontend'){
+        if (mode === 'frontend') {
           rwsPkgName = '@rws-framework/client';
         }
 
         let hasDesiredPackage = false;
 
-        const workspaceWebpackFilePath = path.join(workspaceDir, 'package.json');        
+        const workspaceWebpackFilePath = path.join(workspaceDir, 'package.json');
         const workspacePackageJson = JSON.parse(fs.readFileSync(workspaceWebpackFilePath, 'utf-8'));
 
         if (workspacePackageJson.dependencies && (!!workspacePackageJson.dependencies[rwsPkgName])) {
@@ -72,16 +71,16 @@ function getActiveWorkSpaces(currentPath, mode = 'all') {
   return [currentPath];
 }
 
-async function runCommand(command, cwd = null, silent = false, extraArgs = { env: {}}) {
+async function runCommand(command, cwd = null, silent = false, extraArgs = { env: {} }) {
   return new Promise((resolve, reject) => {
     const [cmd, ...args] = command.split(' ');
-    
-    if(!cwd){
+
+    if (!cwd) {
       console.log(`[RWS] Setting default CWD for "${command}"`);
       cwd = process.cwd();
     }
 
-    
+
     const env = { ...process.env, ...extraArgs.env };
 
     console.log(`[RWS] Running command "${command}" from "${cwd}"`);
@@ -101,7 +100,7 @@ async function runCommand(command, cwd = null, silent = false, extraArgs = { env
   });
 }
 
-function findSuperclassFilePath(entryFile){
+function findSuperclassFilePath(entryFile) {
   const program = ts.createProgram([entryFile], {
     target: ts.ScriptTarget.ES5,
     module: ts.ModuleKind.CommonJS
@@ -136,7 +135,7 @@ function findSuperclassFilePath(entryFile){
   return null; // Return null if no superclass or file path is found
 }
 
-function findServiceFilesWithClassExtend(dir, classPath){
+function findServiceFilesWithClassExtend(dir, classPath) {
   const files = fs.readdirSync(dir);
   let results = []
 
@@ -144,11 +143,11 @@ function findServiceFilesWithClassExtend(dir, classPath){
     const filePath = path.join(dir, file);
     const fileStat = fs.statSync(filePath);
 
-    if (fileStat.isDirectory()) {  
+    if (fileStat.isDirectory()) {
       results = [...results, ...findServiceFilesWithClassExtend(filePath, classPath)];
-    } else if (fileStat.isFile() && filePath.endsWith('.ts')) {  
-      const foundPath = findSuperclassFilePath(filePath);          
-      if(foundPath === classPath){
+    } else if (fileStat.isFile() && filePath.endsWith('.ts')) {
+      const foundPath = findSuperclassFilePath(filePath);
+      if (foundPath === classPath) {
         results = [...results, filePath];
       }
     };
@@ -157,7 +156,7 @@ function findServiceFilesWithClassExtend(dir, classPath){
   return results;
 }
 
-function findComponentFilesWithText(dir, text, ignored = [], fileList = []){
+function findComponentFilesWithText(dir, text, ignored = [], fileList = []) {
   const files = fs.readdirSync(dir);
 
   files.forEach(file => {
@@ -167,15 +166,15 @@ function findComponentFilesWithText(dir, text, ignored = [], fileList = []){
     if (fileStat.isDirectory() && !ignored.includes(file)) {
       // Recursively search this directory
       findComponentFilesWithText(filePath, text, ignored, fileList);
-    } else if (fileStat.isFile() && filePath.endsWith('.ts')) {    
+    } else if (fileStat.isFile() && filePath.endsWith('.ts')) {
       // Read file content and check for text
       const content = fs.readFileSync(filePath, 'utf8');
-      if (content.includes(text)) {                
+      if (content.includes(text)) {
         const compInfo = extractComponentInfo(content);
-        if(compInfo){
-          const {tagName, className, options, isIgnored} = compInfo;
+        if (compInfo) {
+          const { tagName, className, options, isIgnored, isOreo } = compInfo;
 
-          if(isIgnored){
+          if (isIgnored) {
             return;
           }
 
@@ -188,7 +187,8 @@ function findComponentFilesWithText(dir, text, ignored = [], fileList = []){
             className,
             sanitName: className.toLowerCase(),
             content,
-            isIgnored: options?.ignorePackaging
+            isIgnored: options?.ignorePackaging,
+            isOreo: options?.oreoMode
           });
         }
       }
@@ -198,88 +198,88 @@ function findComponentFilesWithText(dir, text, ignored = [], fileList = []){
   return fileList;
 }
 
-function extractRWSViewArguments(sourceFile){
+function extractRWSViewArguments(sourceFile) {
   let argumentsExtracted = {
-      className: null,
-      tagName: null,
-      options: null        
+    className: null,
+    tagName: null,
+    options: null
   };
 
   let foundDecorator = false;
- 
+
   function visit(node) {
-      if (ts.isDecorator(node) && ts.isCallExpression(node.expression)) {
-          const expression = node.expression;
-          const decoratorName = expression.expression.getText(sourceFile);
-          if (decoratorName === 'RWSView') {
-              foundDecorator = true;
-              const args = expression.arguments;
-              if (args.length > 0 && ts.isStringLiteral(args[0])) {
-                argumentsExtracted.tagName = args[0].text;                    
-              }
-              if (args.length > 1) {                  
-                  if (ts.isObjectLiteralExpression(args[1])) {
-                    const argVal = args[1].getText(sourceFile);                    
-                    argumentsExtracted.options = JSON5.parse(argVal);
-                  }
-              } 
-              
-              if (node.parent && ts.isClassDeclaration(node.parent)) {
-                const classNode = node.parent;
-                if (classNode.name) { // ClassDeclaration.name is optional as classes can be unnamed/anonymous
-                  argumentsExtracted.className = classNode.name.getText(sourceFile);
-                }
-              }
+    if (ts.isDecorator(node) && ts.isCallExpression(node.expression)) {
+      const expression = node.expression;
+      const decoratorName = expression.expression.getText(sourceFile);
+      if (decoratorName === 'RWSView') {
+        foundDecorator = true;
+        const args = expression.arguments;
+        if (args.length > 0 && ts.isStringLiteral(args[0])) {
+          argumentsExtracted.tagName = args[0].text;
+        }
+        if (args.length > 1) {
+          if (ts.isObjectLiteralExpression(args[1])) {
+            const argVal = args[1].getText(sourceFile);
+            argumentsExtracted.options = JSON5.parse(argVal);
           }
+        }
+
+        if (node.parent && ts.isClassDeclaration(node.parent)) {
+          const classNode = node.parent;
+          if (classNode.name) { // ClassDeclaration.name is optional as classes can be unnamed/anonymous
+            argumentsExtracted.className = classNode.name.getText(sourceFile);
+          }
+        }
       }
+    }
 
-      ts.forEachChild(node, visit);
+    ts.forEachChild(node, visit);
   }
 
   visit(sourceFile);
 
-  if(!foundDecorator){
+  if (!foundDecorator) {
     return null;
   }
 
   return argumentsExtracted;
 }
 
-function extractRWSIgnoreArguments(sourceFile){
+function extractRWSIgnoreArguments(sourceFile) {
   let argumentsExtracted = {
-      params: null,     
+    params: null,
   };
   let foundDecorator = false;
   let ignored = false;
- 
+
   function visit(node) {
-      if (ts.isDecorator(node) && ts.isCallExpression(node.expression)) {
-          const expression = node.expression;
-          const decoratorName = expression.expression.getText(sourceFile);
-          if (decoratorName === 'RWSView') {
-            foundDecorator = true;
-              const args = expression.arguments;
-         
-              if (args.length) {
-                  // Assuming the second argument is an object literal
-                  if (ts.isObjectLiteralExpression(args[0])) {
-                      const argVal = args[0].getText(sourceFile);                        
-                      argumentsExtracted.options = argVal;                      
-
-                      if(argVal.ignorePackaging === true){
-                        ignored = true;
-                      }
-                  }
-              }                
+    if (ts.isDecorator(node) && ts.isCallExpression(node.expression)) {
+      const expression = node.expression;
+      const decoratorName = expression.expression.getText(sourceFile);
+      if (decoratorName === 'RWSView') {
+        foundDecorator = true;
+        const args = expression.arguments;
+
+        if (args.length) {
+          // Assuming the second argument is an object literal
+          if (ts.isObjectLiteralExpression(args[0])) {
+            const argVal = args[0].getText(sourceFile);
+            argumentsExtracted.options = argVal;
+
+            if (argVal.ignorePackaging === true) {
+              ignored = true;
+            }
           }
+        }
       }
+    }
 
-      ts.forEachChild(node, visit);
+    ts.forEachChild(node, visit);
   }
 
   visit(sourceFile);
 
-  if(!foundDecorator){
+  if (!foundDecorator) {
     return true;
   }
 
@@ -288,8 +288,8 @@ function extractRWSIgnoreArguments(sourceFile){
 
 function extractComponentInfo(componentCode) {
   const componentNameRegex = /\@RWSView/g;
-  
-  if(!componentNameRegex.test(componentCode)){
+
+  if (!componentNameRegex.test(componentCode)) {
     return;
   }
 
@@ -297,92 +297,90 @@ function extractComponentInfo(componentCode) {
 
   let decoratorArgs = extractRWSViewArguments(tsSourceFile);
 
-  if(!decoratorArgs){
+  if (!decoratorArgs) {
     decoratorArgs = {};
   }
 
-  decoratorOpts = decoratorArgs.options;  
+  decoratorOpts = decoratorArgs.options;
 
-  return {...decoratorArgs, options: decoratorOpts };
+  return { ...decoratorArgs, options: decoratorOpts };
 }
 
 function getAllFilesInFolder(folderPath, ignoreFilenames = [], recursive = false) {
   const files = [];
   function traverseDirectory(currentPath) {
-      const entries = fs.readdirSync(currentPath, { withFileTypes: true });
-      entries.forEach(entry => {
-          const entryPath = path.join(currentPath, entry.name);
-          if (entry.isFile()) {
-              let pass = true;
-              ignoreFilenames.forEach((regEx) => {
-                  if (regEx.test(entryPath)) {
-                      pass = false;
-                  }
-              });
-              if (pass) {
-                  files.push(entryPath);
-              }
-          }
-          else if (entry.isDirectory() && recursive) {
-              traverseDirectory(entryPath);
+    const entries = fs.readdirSync(currentPath, { withFileTypes: true });
+    entries.forEach(entry => {
+      const entryPath = path.join(currentPath, entry.name);
+      if (entry.isFile()) {
+        let pass = true;
+        ignoreFilenames.forEach((regEx) => {
+          if (regEx.test(entryPath)) {
+            pass = false;
           }
-      });
+        });
+        if (pass) {
+          files.push(entryPath);
+        }
+      }
+      else if (entry.isDirectory() && recursive) {
+        traverseDirectory(entryPath);
+      }
+    });
   }
   traverseDirectory(folderPath);
   return files;
 }
 
-function setupTsConfig(tsConfigPath, executionDir)
-{
-  
-  if(!fs.existsSync(tsConfigPath)){
-    throw new Error(`Typescript config file "${tsConfigPath}" does not exist`);
-  }  
-
-  console.log('tspath', tsConfigPath);
+function setupTsConfig(tsConfigPath, executionDir) {
 
-  const tsConfigContents = fs.readFileSync(tsConfigPath, 'utf-8');  
+  if (!fs.existsSync(tsConfigPath)) {
+    throw new Error(`Typescript config file "${tsConfigPath}" does not exist`);
+  }
 
-  try{
-    let tsConfig = JSON.parse(tsConfigContents);  
+  const tsConfigContents = fs.readFileSync(tsConfigPath, 'utf-8');
 
+  try {
+    let tsConfig = JSON.parse(tsConfigContents);
+    
     const declarationsPath = path.resolve(__dirname, 'types') + '/declarations.d.ts';
     const testsPath = path.resolve(__dirname, 'tests');
     const declarationsPathMD5 = md5(fs.readFileSync(declarationsPath, 'utf-8'));
-    const testsPathMD5 =  fs.existsSync(testsPath) ? md5(fs.readFileSync(testsPath, 'utf-8')) : null;
-  
+    const testsPathMD5 = fs.existsSync(testsPath) ? md5(fs.readFileSync(testsPath, 'utf-8')) : null;
+
+    const relativeDeclarationsPath = path.relative(path.dirname(tsConfigPath), declarationsPath);
+    const relativeTestsPath = path.relative(path.dirname(tsConfigPath), testsPath);
+
     const includedMD5 = [];
 
-    let changed = false;  
+    let changed = false;    
 
-    const included = [];
-  
-    if(!Object.keys(tsConfig).includes('include')){
+
+    if (!Object.keys(tsConfig).includes('include')) {
       tsConfig['include'] = [];
-    }else{
-      tsConfig['include'] = tsConfig['include'].map((inc) => fs.existsSync(rwsPath.relativize(tsConfig['include'], executionDir)))
-    }
-  
-    if(!Object.keys(tsConfig).includes('exclude')){
+    } else {
+      tsConfig['include'] = tsConfig['include'].filter((inc) => fs.existsSync(rwsPath.relativize(inc, executionDir)))
+    }    
+
+    if (!Object.keys(tsConfig).includes('exclude')) {
       tsConfig['exclude'] = [];
-    }
-  
-    if(!included.includes(declarationsPath) && !includedMD5.includes(declarationsPathMD5)){
+    }  
+
+       
+    if (!tsConfig['include'].includes(relativeDeclarationsPath)) {
       console.log(chalk.blueBright('[RWS TS CONFIG]'), 'adding RWS typescript declarations to project tsconfig.json');
-      included.push(declarationsPath);
-      includedMD5.push(md5(fs.readFileSync(declarationsPath, 'utf-8')));
+      tsConfig['include'].push(relativeDeclarationsPath);
+      includedMD5.push(md5(fs.readFileSync(declarationsPath, 'utf-8')));      
       changed = true;
-    }
-  
-    tsConfig['include'] = included;
-  
-    if(testsPathMD5 && (!tsConfig['exclude'].includes(testsPath) && !included.includes(testsPathMD5))){
+    }    
+
+    if ((!tsConfig['exclude'].includes(relativeTestsPath))) {
       console.log(chalk.blueBright('[RWS TS CONFIG]'), 'adding RWS typescript exclusions to project tsconfig.json');
-      tsConfig['exclude'].push(testsPath);      
+      tsConfig['exclude'].push(relativeTestsPath);      
       changed = true;
     }
-  
-    if(changed){
+
+    if (changed) {      
       fs.writeFileSync(tsConfigPath, JSON.stringify(tsConfig, null, 2));
       console.log(chalk.yellowBright('Typescript config file'), `"${chalk.blueBright(tsConfigPath)}"`, chalk.yellowBright('has been changed'));
     }
@@ -396,17 +394,35 @@ function setupTsConfig(tsConfigPath, executionDir)
   }
 }
 
+function getPartedModeVendorsBannerParams(partedDirUrlPrefix, partedPrefix) {
+  return {
+    banner: `if(!window.RWS_PARTS_LOADED){         
+            const script = document.createElement('script');
+            script.src = '${partedDirUrlPrefix}/${partedPrefix}.vendors.js';        
+            script.type = 'text/javascript';
+            document.body.appendChild(script);
+            window.RWS_PARTS_LOADED = true;
+            console.log('[RWS INIT SCRIPT]', 'vendors injected...');
+          }`.replace('\n', ''),
+    raw: true,
+    entryOnly: true,
+    include: `${partedPrefix}.client.js`
+  };
+}
+
+
 module.exports = {
-    findRootWorkspacePath,
-    findPackageDir,
-    getActiveWorkSpaces,
-    runCommand,
-    findComponentFilesWithText,
-    extractComponentInfo,
-    extractRWSViewArguments,
-    extractRWSIgnoreArguments,
-    findServiceFilesWithClassExtend,
-    findSuperclassFilePath,
-    getAllFilesInFolder,
-    setupTsConfig
+  findRootWorkspacePath,
+  findPackageDir,
+  getActiveWorkSpaces,
+  runCommand,
+  findComponentFilesWithText,
+  extractComponentInfo,
+  extractRWSViewArguments,
+  extractRWSIgnoreArguments,
+  findServiceFilesWithClassExtend,
+  findSuperclassFilePath,
+  getAllFilesInFolder,
+  setupTsConfig,
+  getPartedModeVendorsBannerParams
 }

package/cfg/_default.cfg.js

@@ -5,7 +5,7 @@ const _DEFAULT_CONFIG_VARS = {
     report: false,   
     publicDir: './public',
     publicIndex: 'index.html',      
-    outputFileName: 'client.rws.js',
+    outputFileName: 'rws.client.js',
     outputDir: './build',
     tsConfigPath: './tsconfig.json',
     //Frontend RWS client configs