@tixyel/cli 2.6.2 → 2.6.4

package/dist/widget.js

@@ -278,20 +278,28 @@ export async function processBuild(widget, workspaceConfig, verbose = false) {
     // const results: Record<string, string> = {};
     const normalizeList = (value) => (Array.isArray(value) ? value.filter(Boolean) : []);
     const findAndRead = (baseDir, patterns) => {
-        const contents = [];
+        const contents = {};
         for (const pattern of patterns) {
             const fullPath = join(baseDir, pattern);
             if (existsSync(fullPath)) {
                 const content = readFileSync(fullPath, 'utf-8');
-                contents.push(content);
+                contents[pattern] = content;
             }
         }
         return contents;
     };
     const usedWatermarks = new Set();
+    const processedFile = new Set();
+    /**
+     * Build results processing
+     * Find all files based on patterns and process them according to their type
+     * (html, css, script, fields)
+     * Group results based on resultMapping and compactedMapping
+     * Compact/minify where applicable
+     */
     const results = Object.fromEntries(await Promise.all(Object.entries(findPatterns).map(async ([key, patterns]) => {
         let result = '';
-        const list = normalizeList(patterns);
+        let list = normalizeList(patterns.filter((p) => !processedFile.has(p)));
         if (!list.length)
             return [key, ''];
         const check = (keys, formats) => {
@@ -303,46 +311,39 @@ export async function processBuild(widget, workspaceConfig, verbose = false) {
                 // check formats
                 list.some((p) => formats.some((f) => p.toLowerCase().endsWith(f.toLowerCase()))));
         };
+        const processed = new Set();
         // Process HTML
         if (check('html', '.html')) {
             if (!usedWatermarks.has('html'))
                 result += watermark.html(widget) + '\n';
             usedWatermarks.add('html');
+            const fileList = list.filter((e) => e.endsWith('.html') && !processedFile.has(e));
             if (verbose)
-                console.log(`  - Processing HTML...`);
-            const files = findAndRead(entryDir, list);
+                console.log(`  - Processing HTML for ${widget.config.name} [${key}, ${fileList.join(', ')}]...`);
+            const files = findAndRead(entryDir, fileList);
             let mergedHTML = '';
-            for await (const fileContent of files) {
+            for await (const [pattern, fileContent] of Object.entries(files)) {
                 // Extract body content
                 const bodyMatch = fileContent.match(/<body[^>]*>([\s\S]*?)<\/body>/i);
                 if (bodyMatch && bodyMatch[1]) {
                     mergedHTML += bodyMatch[1].trim() + '\n';
-                }
-                // Extract and inline styles
-                const styleMatches = fileContent.matchAll(/<style[^>]*>([\s\S]*?)<\/style>/gi);
-                for (const match of styleMatches) {
-                    mergedHTML += `<style>${match[1]}</style>\n`;
-                }
-                // Extract and inline <script> tags
-                const scriptMatches = fileContent.matchAll(/<script[^>]*>([\s\S]*?)<\/script>/gi);
-                for (const match of scriptMatches) {
-                    if (match[1]) {
-                        mergedHTML += `<script>${match[1]}</script>\n`;
-                    }
+                    processedFile.add(pattern);
                 }
             }
             const minified = await minifyHTML(mergedHTML, workspaceConfig.build?.obfuscation?.html);
             result += minified.trim();
+            processed.add('html');
         }
-        else if (check(['css', 'style', 'styles'], '.css')) {
+        if (check(['css', 'style', 'styles'], '.css')) {
             if (!usedWatermarks.has('css'))
                 result += watermark.css(widget) + '\n';
             usedWatermarks.add('css');
+            const fileList = list.filter((e) => e.endsWith('.css') && !processedFile.has(e));
             if (verbose)
-                console.log(`  - Processing CSS...`);
-            const files = findAndRead(entryDir, list);
+                console.log(`  - Processing CSS for ${widget.config.name} [${key}, ${fileList.join(', ')}]...`);
+            const files = findAndRead(entryDir, fileList);
             let mergedCSS = '';
-            for await (const content of files) {
+            for await (const [pattern, content] of Object.entries(files)) {
                 const plugin = [
                     autoprefixer({
                         overrideBrowserslist: ['Chrome 127'],
@@ -355,32 +356,25 @@ export async function processBuild(widget, workspaceConfig, verbose = false) {
                 }
                 const processed = await postcss(plugin).process(content, { from: undefined });
                 mergedCSS += processed.css + '\n';
+                processedFile.add(pattern);
             }
-            result += mergedCSS.trim();
-        }
-        else if (check(['script', 'js', 'javascript'], '.js')) {
-            if (!usedWatermarks.has('script'))
-                result += watermark.script(widget) + '\n';
-            usedWatermarks.add('script');
-            if (verbose)
-                console.log(`  - Processing JavaScript...`);
-            const files = findAndRead(entryDir, list);
-            let mergedJS = '';
-            for await (const content of files) {
-                const obfuscated = JavaScriptObfuscator.obfuscate(content, workspaceConfig.build?.obfuscation?.javascript);
-                mergedJS += obfuscated.getObfuscatedCode() + '\n';
+            if (processed.has('html')) {
+                result = result += `<style>${mergedCSS.trim()}</style>`;
             }
-            result += mergedJS.trim();
+            else
+                result += mergedCSS.trim();
+            processed.add('css');
         }
-        else if (check(['typescript', 'ts'], '.ts')) {
+        if (check(['typescript', 'ts'], '.ts')) {
             if (!usedWatermarks.has('script'))
                 result += watermark.script(widget) + '\n';
             usedWatermarks.add('script');
+            const fileList = list.filter((e) => e.endsWith('.ts') && !processedFile.has(e));
             if (verbose)
-                console.log(`  - Processing TypeScript...`);
-            const files = findAndRead(entryDir, list);
+                console.log(`  - Processing TypeScript for ${widget.config.name} [${key}, ${fileList.join(', ')}]...`);
+            const files = findAndRead(entryDir, fileList);
             let mergedTS = '';
-            for await (const content of files) {
+            for await (const [pattern, content] of Object.entries(files)) {
                 try {
                     const transpiled = transformSync(content, {
                         loader: 'ts',
@@ -393,17 +387,47 @@ export async function processBuild(widget, workspaceConfig, verbose = false) {
                     console.warn(`   ⚠️  Failed to compile TypeScript: ${error}`);
                     throw error;
                 }
+                finally {
+                    processedFile.add(pattern);
+                }
             }
             // Obfuscate the compiled JavaScript
             const obfuscated = JavaScriptObfuscator.obfuscate(mergedTS.trim(), workspaceConfig.build?.obfuscation?.javascript);
-            result += obfuscated.getObfuscatedCode();
+            if (processed.has('html')) {
+                result = result += `<script>${obfuscated.getObfuscatedCode()}</script>`;
+            }
+            else
+                result += obfuscated.getObfuscatedCode();
+            processed.add('typescript');
         }
-        else if (check(['fields', 'fielddata', 'fieldData', 'cf', 'customfields'], '.json')) {
+        if (check(['script', 'js', 'javascript'], '.js')) {
+            if (!usedWatermarks.has('script'))
+                result += watermark.script(widget) + '\n';
+            usedWatermarks.add('script');
+            const fileList = list.filter((e) => e.endsWith('.js') && !processedFile.has(e));
+            if (verbose)
+                console.log(`  - Processing JavaScript for ${widget.config.name} [${key}, ${fileList.join(', ')}]...`);
+            const files = findAndRead(entryDir, fileList);
+            let mergedJS = '';
+            for await (const [pattern, content] of Object.entries(files)) {
+                const obfuscated = JavaScriptObfuscator.obfuscate(content, workspaceConfig.build?.obfuscation?.javascript);
+                mergedJS += obfuscated.getObfuscatedCode() + '\n';
+                processedFile.add(pattern);
+            }
+            if (processed.has('html')) {
+                result = result += `<script>${mergedJS.trim()}</script>`;
+            }
+            else
+                result += mergedJS.trim();
+            processed.add('script');
+        }
+        if (check(['fields', 'fielddata', 'fieldData', 'cf', 'customfields'], '.json')) {
+            const fileList = list.filter((e) => e.endsWith('.json') && !processedFile.has(e));
             if (verbose)
-                console.log(`  - Processing Json...`);
-            const files = findAndRead(entryDir, list);
+                console.log(`  - Processing JSON for ${widget.config.name} [${key}, ${fileList.join(', ')}]...`);
+            const files = findAndRead(entryDir, fileList);
             let mergedFields = {};
-            for await (const content of files) {
+            for await (const [pattern, content] of Object.entries(files)) {
                 try {
                     const noComments = parse(content);
                     const parsed = JSON.parse(JSON.stringify(noComments));
@@ -414,15 +438,22 @@ export async function processBuild(widget, workspaceConfig, verbose = false) {
                     throw error;
                 }
             }
-            result += JSON.stringify(mergedFields, null, 2);
+            if (!processed.size)
+                result += JSON.stringify(mergedFields, null, 2);
+            processed.add('fields');
         }
-        else {
+        if (!result.length) {
             if (verbose)
                 console.log(`  - Unknown build key: ${key}, the available keys are html, css, script and fields.`);
             result += '';
         }
         return [key, result];
     })));
+    if (verbose) {
+        console.log(`   - Build results:`, Object.keys(results)
+            .map((k) => `${k}: ${results[k].length} bytes`)
+            .join(', '));
+    }
     for await (const [filename, key] of Object.entries(resultMapping)) {
         let content = '';
         if (typeof key === 'string')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tixyel/cli",
-  "version": "2.6.2",
+  "version": "2.6.4",
   "description": "CLI tool for streamelements widgets",
   "keywords": [
     "cli",