@rws-framework/client 2.13.2 → 2.13.3

package/builder/webpack/rws_webpack_plugin.js

@@ -1,138 +1,138 @@
-const rwsAfterCopy = require('./after/copy');
-const rwsAfterSW = require('./after/sw');
-const deepmerge = require('deepmerge');
-
-
-const _DEFAULT_CONFIG = { actions: [], executionDir: process.cwd(), packageDir: process.cwd(), dev: false, devDebug: null }
-
-const _DEFAULT_ACTION = {
-    type: 'copy',
-    actionHandler: {
-        'targetDir': [
-            'filePath0',
-            'filePath1'
-        ]
-    },
-    event: 'done'
-}
-
-class RWSWebpackPlugin {
-    config = _DEFAULT_CONFIG;
-    _allowedActionTypes = ['copy', 'custom', 'service_worker'];
-
-    constructor(config = {}) {
-        this.config = deepmerge(this.config, config);
-        this.customOptions = {
-            devDebug: this.config.devDebug
-        }
-    }
-
-    apply(compiler) {
-        const actionsEvents = this.config.actions.map(item => item.event ? item.event : 'done');
-        const errorActionsEvents = this.config.error_actions.map(item => item.event ? item.event : null).filter(item => !!item);
-
-        compiler.hooks.compilation.tap('RWSWebpackPlugin', (compilation) => {            
-            compilation['customOptions'] = this.customOptions;            
-        });
-
-        Array.from(new Set(actionsEvents)).forEach((eventName) => {
-            compiler.hooks[eventName].tapPromise('RWSWebpackPlugin', async (buildInfo) => {
-                const proms = this.config.actions.filter(item => item.event === _DEFAULT_ACTION.event || !item.event).map(async (rwsAfterAction) => {
-                    return await this._runActionType(rwsAfterAction.type, rwsAfterAction.actionHandler);
-                });
-
-                return await Promise.all(proms);
-            });
-        });
-
-        if (!this.config.dev) {
-            compiler.hooks.emit.tapAsync('RWSWebpackPlugin', (compilation, callback) => {
-                Object.keys(compilation.assets).forEach((filename) => {
-
-                    if (filename.endsWith('.js')) {
-                        const asset = compilation.assets[filename];
-                        let source = asset.source();
-
-                        if ((source.indexOf('css`') > -1 || source.indexOf('html`') > -1)) {
-                            const updatedSource = source.replace(/\n/g, '');
-
-                            // Update the asset with the new content
-                            compilation.assets[filename] = {
-                                source: () => updatedSource,
-                                size: () => updatedSource.length
-                            };
-                        }
-                    }
-                });
-
-                callback();
-            });
-        }
-
-        // compiler.hooks.done.tap('RWSWebpackPlugin', (stats) => {
-        //     // Check if there were any errors
-        //     if (stats.hasErrors()) {
-        //         console.error('Build failed with errors:');
-
-        //         // Log the errors
-        //         const info = stats.toJson();
-        //         console.error(info.errors);
-
-        //         Array.from(new Set(actionsEvents)).forEach((eventName) => {
-        //             compiler.hooks[eventName].tapPromise('RWSWebpackPlugin', async (buildInfo) => {
-        //                 const proms = this.config.actions.filter(item => item.event === _DEFAULT_ACTION.event || !item.event).map(async (rwsAfterAction) => {
-        //                     return await this._runActionType(rwsAfterAction.type, rwsAfterAction.actionHandler);
-        //                 });
-
-        //                 return await Promise.all(proms);
-        //             });
-        //         });
-
-        //         // Optionally exit the process with a non-zero status
-        //         process.exit(1);
-        //     } else {
-        //         console.log('Build completed successfully.');
-        //     }
-        // });
-    }
-
-    async _runActionType(actionType, action) {
-        if (!this._allowedActionTypes.includes(actionType)) {
-            throw new Error(`[RWSAfter webpack plugin] Action type ${actionType} is not allowed`);
-        }
-
-        switch (actionType) {
-            case 'copy': {
-                const copyFiles = typeof action === 'function' ? await action() : action;
-
-                await rwsAfterCopy(copyFiles, this.config);
-                return;
-            };
-
-            //@TODO
-            case 'service_worker': {
-
-                const serviceWorkerPath = typeof action === 'function' ? await action() : action;
-                await rwsAfterSW(serviceWorkerPath);
-                return;
-            };
-
-            case 'custom': {
-
-                if (typeof action !== 'function') {
-                    console.error('Custom RWS action must be a function.')
-                    return;
-                }
-
-                await action();
-                return;
-            }
-
-            default:
-                console.warn('RWSWebpackPlugin::_runActionType could not act upon input. Please resolve.');
-                return;
-        }
-    }
-}
-
+const rwsAfterCopy = require('./after/copy');
+const rwsAfterSW = require('./after/sw');
+const deepmerge = require('deepmerge');
+
+
+const _DEFAULT_CONFIG = { actions: [], executionDir: process.cwd(), packageDir: process.cwd(), dev: false, devDebug: null }
+
+const _DEFAULT_ACTION = {
+    type: 'copy',
+    actionHandler: {
+        'targetDir': [
+            'filePath0',
+            'filePath1'
+        ]
+    },
+    event: 'done'
+}
+
+class RWSWebpackPlugin {
+    config = _DEFAULT_CONFIG;
+    _allowedActionTypes = ['copy', 'custom', 'service_worker'];
+
+    constructor(config = {}) {
+        this.config = deepmerge(this.config, config);
+        this.customOptions = {
+            devDebug: this.config.devDebug
+        }
+    }
+
+    apply(compiler) {
+        const actionsEvents = this.config.actions.map(item => item.event ? item.event : 'done');
+        const errorActionsEvents = this.config.error_actions.map(item => item.event ? item.event : null).filter(item => !!item);
+
+        compiler.hooks.compilation.tap('RWSWebpackPlugin', (compilation) => {            
+            compilation['customOptions'] = this.customOptions;            
+        });
+
+        Array.from(new Set(actionsEvents)).forEach((eventName) => {
+            compiler.hooks[eventName].tapPromise('RWSWebpackPlugin', async (buildInfo) => {
+                const proms = this.config.actions.filter(item => item.event === _DEFAULT_ACTION.event || !item.event).map(async (rwsAfterAction) => {
+                    return await this._runActionType(rwsAfterAction.type, rwsAfterAction.actionHandler);
+                });
+
+                return await Promise.all(proms);
+            });
+        });
+
+        if (!this.config.dev) {
+            compiler.hooks.emit.tapAsync('RWSWebpackPlugin', (compilation, callback) => {
+                Object.keys(compilation.assets).forEach((filename) => {
+
+                    if (filename.endsWith('.js')) {
+                        const asset = compilation.assets[filename];
+                        let source = asset.source();
+
+                        if ((source.indexOf('css`') > -1 || source.indexOf('html`') > -1)) {
+                            const updatedSource = source.replace(/\n/g, '');
+
+                            // Update the asset with the new content
+                            compilation.assets[filename] = {
+                                source: () => updatedSource,
+                                size: () => updatedSource.length
+                            };
+                        }
+                    }
+                });
+
+                callback();
+            });
+        }
+
+        // compiler.hooks.done.tap('RWSWebpackPlugin', (stats) => {
+        //     // Check if there were any errors
+        //     if (stats.hasErrors()) {
+        //         console.error('Build failed with errors:');
+
+        //         // Log the errors
+        //         const info = stats.toJson();
+        //         console.error(info.errors);
+
+        //         Array.from(new Set(actionsEvents)).forEach((eventName) => {
+        //             compiler.hooks[eventName].tapPromise('RWSWebpackPlugin', async (buildInfo) => {
+        //                 const proms = this.config.actions.filter(item => item.event === _DEFAULT_ACTION.event || !item.event).map(async (rwsAfterAction) => {
+        //                     return await this._runActionType(rwsAfterAction.type, rwsAfterAction.actionHandler);
+        //                 });
+
+        //                 return await Promise.all(proms);
+        //             });
+        //         });
+
+        //         // Optionally exit the process with a non-zero status
+        //         process.exit(1);
+        //     } else {
+        //         console.log('Build completed successfully.');
+        //     }
+        // });
+    }
+
+    async _runActionType(actionType, action) {
+        if (!this._allowedActionTypes.includes(actionType)) {
+            throw new Error(`[RWSAfter webpack plugin] Action type ${actionType} is not allowed`);
+        }
+
+        switch (actionType) {
+            case 'copy': {
+                const copyFiles = typeof action === 'function' ? await action() : action;
+
+                await rwsAfterCopy(copyFiles, this.config);
+                return;
+            };
+
+            //@TODO
+            case 'service_worker': {
+
+                const serviceWorkerPath = typeof action === 'function' ? await action() : action;
+                await rwsAfterSW(serviceWorkerPath);
+                return;
+            };
+
+            case 'custom': {
+
+                if (typeof action !== 'function') {
+                    console.error('Custom RWS action must be a function.')
+                    return;
+                }
+
+                await action();
+                return;
+            }
+
+            default:
+                console.warn('RWSWebpackPlugin::_runActionType could not act upon input. Please resolve.');
+                return;
+        }
+    }
+}
+
 module.exports = RWSWebpackPlugin;

package/builder/webpack/scss/_compiler.js

@@ -1,98 +1,98 @@
-const sass = require('sass');
-const path = require('path');
-const chalk = require('chalk');
-const emojiRegex = require('emoji-regex');
-
-const _scss_fonts_builder = require('./_fonts');
-let _scss_fonts = null;
-
-const _scss_import_builder = require('./_import');
-let _scss_import = null;
-
-function compileScssCode(scssCode, fileRootDir, createFile = false, filePath = null, minify = false) {  
-    _scss_fonts = _scss_fonts_builder(this);
-    _scss_import = _scss_import_builder(this);
-
-    const [scssImports] = _scss_import.extractScssImports(scssCode, fileRootDir);
-
-    const dependencies = scssImports.map((item) => item[2]);
-
-    if (scssImports && scssImports.length) {
-      scssCode = _scss_import.replaceImports(_scss_import.processImports(scssImports, fileRootDir), scssCode);
-    }
-
-    const uses = _scss_import.extractScssUses(scssCode)[0];
-    let scssUses = '';
-
-
-    uses.forEach(scssUse => {
-      const useLine = scssUse[1];
-      if(scssCode.indexOf(useLine) === -1){                
-        scssUses += useLine + '\n';
-        scssCode = scssCode.replace(useLine + '\n', '');
-      }
-    });
-
-    scssCode = removeComments(scssUses + scssCode);
-
-    try {
-      const result = sass.compileString(scssCode, { loadPaths: [fileRootDir]});
-
-      let compiledCode = result.css.toString();
-      compiledCode = _scss_fonts.replaceFontUrlWithBase64(compiledCode);
-      compiledCode = replaceEmojisWithQuestionMark(compiledCode, fileRootDir);
-      return { code: compiledCode, dependencies};
-    } catch (err) {
-      console.error('SASS Error in', fileRootDir);
-
-      console.error(err);
-      throw err;
-      return '';
-    };
-  }
-
-  function checkForImporterType(_module, checkTypeExt) {
-    let importingFileExtension = '';
-
-    if (_module && _module.issuer && _module.issuer.resource) {
-      importingFileExtension = path.extname(_module.issuer.resource);
-      if (importingFileExtension === ('.' + checkTypeExt)) {
-        return true;
-      }
-    } else {
-      return false;
-    }
-
-    return false
-  }
-
-  function replaceEmojisWithQuestionMark(code, componentDir) {
-    const regex = emojiRegex();
-    let hasEmoji = false;
-    
-    const result = code.replace(regex, (match) => {
-      hasEmoji = true;
-      return '?';
-    });
-  
-    if (hasEmoji) {
-      console.log(chalk.yellow(`Emojis in css detected and replaced with "?" in "${path.dirname(componentDir)}" component`));
-    }
-  
-    return result;
-  }
-
-  function removeComments(code) {
-    code = code.replace(/\/\/.*$/gm, '');
-    code = code.replace(/\/\*[\s\S]*?\*\//g, '');
-    code = code.replace(/^\s*$(?:\r\n?|\n)/gm, '');
-    
-    return code;
-  }
-  
-  module.exports = function(element) {
-    return {
-        checkForImporterType: checkForImporterType.bind(element),
-        compileScssCode: compileScssCode.bind(element)
-    };
+const sass = require('sass');
+const path = require('path');
+const chalk = require('chalk');
+const emojiRegex = require('emoji-regex');
+
+const _scss_fonts_builder = require('./_fonts');
+let _scss_fonts = null;
+
+const _scss_import_builder = require('./_import');
+let _scss_import = null;
+
+function compileScssCode(scssCode, fileRootDir, createFile = false, filePath = null, minify = false) {  
+    _scss_fonts = _scss_fonts_builder(this);
+    _scss_import = _scss_import_builder(this);
+
+    const [scssImports] = _scss_import.extractScssImports(scssCode, fileRootDir);
+
+    const dependencies = scssImports.map((item) => item[2]);
+
+    if (scssImports && scssImports.length) {
+      scssCode = _scss_import.replaceImports(_scss_import.processImports(scssImports, fileRootDir), scssCode);
+    }
+
+    const uses = _scss_import.extractScssUses(scssCode)[0];
+    let scssUses = '';
+
+
+    uses.forEach(scssUse => {
+      const useLine = scssUse[1];
+      if(scssCode.indexOf(useLine) === -1){                
+        scssUses += useLine + '\n';
+        scssCode = scssCode.replace(useLine + '\n', '');
+      }
+    });
+
+    scssCode = removeComments(scssUses + scssCode);
+
+    try {
+      const result = sass.compileString(scssCode, { loadPaths: [fileRootDir]});
+
+      let compiledCode = result.css.toString();
+      compiledCode = _scss_fonts.replaceFontUrlWithBase64(compiledCode);
+      compiledCode = replaceEmojisWithQuestionMark(compiledCode, fileRootDir);
+      return { code: compiledCode, dependencies};
+    } catch (err) {
+      console.error('SASS Error in', fileRootDir);
+
+      console.error(err);
+      throw err;
+      return '';
+    };
+  }
+
+  function checkForImporterType(_module, checkTypeExt) {
+    let importingFileExtension = '';
+
+    if (_module && _module.issuer && _module.issuer.resource) {
+      importingFileExtension = path.extname(_module.issuer.resource);
+      if (importingFileExtension === ('.' + checkTypeExt)) {
+        return true;
+      }
+    } else {
+      return false;
+    }
+
+    return false
+  }
+
+  function replaceEmojisWithQuestionMark(code, componentDir) {
+    const regex = emojiRegex();
+    let hasEmoji = false;
+    
+    const result = code.replace(regex, (match) => {
+      hasEmoji = true;
+      return '?';
+    });
+  
+    if (hasEmoji) {
+      console.log(chalk.yellow(`Emojis in css detected and replaced with "?" in "${path.dirname(componentDir)}" component`));
+    }
+  
+    return result;
+  }
+
+  function removeComments(code) {
+    code = code.replace(/\/\/.*$/gm, '');
+    code = code.replace(/\/\*[\s\S]*?\*\//g, '');
+    code = code.replace(/^\s*$(?:\r\n?|\n)/gm, '');
+    
+    return code;
+  }
+  
+  module.exports = function(element) {
+    return {
+        checkForImporterType: checkForImporterType.bind(element),
+        compileScssCode: compileScssCode.bind(element)
+    };
   };

package/builder/webpack/scss/_fonts.js

@@ -1,81 +1,81 @@
-const fs = require('fs');
-const path = require('path');
-const FONT_REGEX = /url\(['"]?(.+?\.(woff|woff2|eot|ttf|otf))['"]?\)/gm;
-
-const _scss_import_builder = require('./_import');
-let _scss_import = null;
-
-function hasFontEmbeds(css) {
-    return FONT_REGEX.test(css);
-}
-
-function embedFontsInCss(css, cssFilePath) {
-    let match;
-
-    while ((match = FONT_REGEX.exec(css)) !== null) {
-        const fontPath = match[1];
-        const absoluteFontPath = path.resolve(path.dirname(cssFilePath), fontPath);
-
-        if (fs.existsSync(absoluteFontPath)) {
-            const fontData = fs.readFileSync(absoluteFontPath);
-            const base64Font = fontData.toString('base64');
-            const fontMimeType = getFontMimeType(path.extname(absoluteFontPath));
-            const fontDataURL = `data:${fontMimeType};base64,${base64Font}`;
-
-            css = css.replace(new RegExp(match[0], 'g'), `url(${fontDataURL})`);
-        }
-    }
-
-    return css;
-}
-
-function getFontMimeType(extension) {
-    switch (extension) {
-        case '.woff': return 'font/woff';
-        case '.woff2': return 'font/woff2';
-        case '.eot': return 'application/vnd.ms-fontobject';
-        case '.ttf': return 'font/ttf';
-        case '.otf': return 'font/otf';
-        default: return 'application/octet-stream';
-    }
-}
-
-function convertFontToBase64(fontPath) {
-    return fs.readFileSync(fontPath, { encoding: 'base64' });
-}
-
-function replaceFontUrlWithBase64(cssContent) {
-    const fontFaceRegex = /@font-face\s*\{[^}]*\}/g;
-    let fontFaces = [...cssContent.matchAll(fontFaceRegex)];
-    _scss_import = _scss_import_builder(this);
-
-    for (const fontFace of fontFaces) {
-        const fontFaceContent = fontFace[0];
-        const urlRegex = /url\((['"]?)([^)'"]+)(\1)\)/g;
-        let match;
-
-        let modifiedFontFaceContent = fontFaceContent;
-
-        while ((match = urlRegex.exec(fontFaceContent)) !== null) {
-            // Create a promise to convert each font to Base64 and replace in CSS
-            const base64 = convertFontToBase64(_scss_import.processImportPath(match[2], null, true));
-            const base64Font = `data:font/woff2;base64,${base64}`;
-
-            modifiedFontFaceContent = modifiedFontFaceContent.replace(match[2], base64Font);
-        }
-
-        cssContent = cssContent.replace(fontFaceContent, modifiedFontFaceContent)
-    };
-
-    return cssContent;
-}
-
-module.exports = function(element) {
-    return {
-        hasFontEmbeds: hasFontEmbeds.bind(element),
-        embedFontsInCss: embedFontsInCss.bind(element),
-        getFontMimeType: getFontMimeType.bind(element),
-        convertFontToBase64: convertFontToBase64.bind(element),
-        replaceFontUrlWithBase64: replaceFontUrlWithBase64.bind(element)
-    };
+const fs = require('fs');
+const path = require('path');
+const FONT_REGEX = /url\(['"]?(.+?\.(woff|woff2|eot|ttf|otf))['"]?\)/gm;
+
+const _scss_import_builder = require('./_import');
+let _scss_import = null;
+
+function hasFontEmbeds(css) {
+    return FONT_REGEX.test(css);
+}
+
+function embedFontsInCss(css, cssFilePath) {
+    let match;
+
+    while ((match = FONT_REGEX.exec(css)) !== null) {
+        const fontPath = match[1];
+        const absoluteFontPath = path.resolve(path.dirname(cssFilePath), fontPath);
+
+        if (fs.existsSync(absoluteFontPath)) {
+            const fontData = fs.readFileSync(absoluteFontPath);
+            const base64Font = fontData.toString('base64');
+            const fontMimeType = getFontMimeType(path.extname(absoluteFontPath));
+            const fontDataURL = `data:${fontMimeType};base64,${base64Font}`;
+
+            css = css.replace(new RegExp(match[0], 'g'), `url(${fontDataURL})`);
+        }
+    }
+
+    return css;
+}
+
+function getFontMimeType(extension) {
+    switch (extension) {
+        case '.woff': return 'font/woff';
+        case '.woff2': return 'font/woff2';
+        case '.eot': return 'application/vnd.ms-fontobject';
+        case '.ttf': return 'font/ttf';
+        case '.otf': return 'font/otf';
+        default: return 'application/octet-stream';
+    }
+}
+
+function convertFontToBase64(fontPath) {
+    return fs.readFileSync(fontPath, { encoding: 'base64' });
+}
+
+function replaceFontUrlWithBase64(cssContent) {
+    const fontFaceRegex = /@font-face\s*\{[^}]*\}/g;
+    let fontFaces = [...cssContent.matchAll(fontFaceRegex)];
+    _scss_import = _scss_import_builder(this);
+
+    for (const fontFace of fontFaces) {
+        const fontFaceContent = fontFace[0];
+        const urlRegex = /url\((['"]?)([^)'"]+)(\1)\)/g;
+        let match;
+
+        let modifiedFontFaceContent = fontFaceContent;
+
+        while ((match = urlRegex.exec(fontFaceContent)) !== null) {
+            // Create a promise to convert each font to Base64 and replace in CSS
+            const base64 = convertFontToBase64(_scss_import.processImportPath(match[2], null, true));
+            const base64Font = `data:font/woff2;base64,${base64}`;
+
+            modifiedFontFaceContent = modifiedFontFaceContent.replace(match[2], base64Font);
+        }
+
+        cssContent = cssContent.replace(fontFaceContent, modifiedFontFaceContent)
+    };
+
+    return cssContent;
+}
+
+module.exports = function(element) {
+    return {
+        hasFontEmbeds: hasFontEmbeds.bind(element),
+        embedFontsInCss: embedFontsInCss.bind(element),
+        getFontMimeType: getFontMimeType.bind(element),
+        convertFontToBase64: convertFontToBase64.bind(element),
+        replaceFontUrlWithBase64: replaceFontUrlWithBase64.bind(element)
+    };
 };