ultimate-jekyll-manager 0.0.93 → 0.0.95

package/dist/commands/migrate.js

@@ -0,0 +1,331 @@
+// Libraries
+const Manager = new (require('../build.js'));
+const logger = Manager.logger('migrate');
+const { execute } = require('node-powertools');
+const path = require('path');
+const jetpack = require('fs-jetpack');
+
+// Load package
+const package = Manager.getPackage('main');
+
+module.exports = async function () {
+  // Log
+  logger.log(`Starting migration to Ultimate Jekyll v${package.version}...`);
+  logger.log(`Current working directory: ${process.cwd()}`);
+
+  try {
+    // Run migration tasks
+    await migratePosts();
+    await migrateAssets();
+    await fixPostsLayout();
+    await fixPostFilenames();
+
+    // Log completion
+    logger.log(logger.format.green('✓ Migration complete!'));
+  } catch (e) {
+    logger.error('Migration failed:', e);
+    throw e;
+  }
+};
+
+async function migratePosts() {
+  const sourcePath = path.join(process.cwd(), '_posts');
+  const targetPath = path.join(process.cwd(), 'src', '_posts');
+
+  // Check if _posts exists in root
+  const sourceExists = jetpack.exists(sourcePath);
+
+  if (!sourceExists) {
+    logger.log('No _posts directory found in root - skipping posts migration');
+    return;
+  }
+
+  // Check if target already exists
+  const targetExists = jetpack.exists(targetPath);
+
+  if (targetExists) {
+    logger.warn(`Target directory ${targetPath} already exists!`);
+    logger.log('Checking for conflicts...');
+
+    // Get list of files in both directories
+    const sourceFiles = jetpack.list(sourcePath) || [];
+    const targetFiles = jetpack.list(targetPath) || [];
+
+    // Find conflicts
+    const conflicts = sourceFiles.filter((file) => targetFiles.includes(file));
+
+    if (conflicts.length > 0) {
+      logger.warn(`Found ${conflicts.length} conflicting file(s):`);
+      conflicts.forEach((file) => logger.warn(`  - ${file}`));
+      throw new Error('Cannot migrate _posts: conflicts detected. Please resolve manually.');
+    }
+  }
+
+  // Log the migration
+  logger.log(`Migrating _posts from root to src/...`);
+  logger.log(`  Source: ${sourcePath}`);
+  logger.log(`  Target: ${targetPath}`);
+
+  // Ensure target directory exists
+  jetpack.dir(path.dirname(targetPath));
+
+  // Move the directory
+  jetpack.move(sourcePath, targetPath);
+
+  // Verify the move
+  const moveSuccessful = jetpack.exists(targetPath)
+    && !jetpack.exists(sourcePath);
+
+  if (moveSuccessful) {
+    logger.log(logger.format.green('✓ Successfully migrated _posts to src/_posts'));
+  } else {
+    throw new Error('Failed to migrate _posts directory');
+  }
+}
+
+async function migrateAssets() {
+  const sourcePath = path.join(process.cwd(), 'assets');
+  const targetPath = path.join(process.cwd(), 'src', 'assets');
+
+  // Check if assets exists in root
+  const sourceExists = jetpack.exists(sourcePath);
+
+  if (!sourceExists) {
+    logger.log('No assets directory found in root - skipping assets migration');
+    return;
+  }
+
+  // Check if target already exists
+  const targetExists = jetpack.exists(targetPath);
+
+  if (targetExists) {
+    logger.warn(`Target directory ${targetPath} already exists!`);
+    logger.log('Merging assets directories...');
+
+    // Get list of files in both directories (recursively)
+    const sourceFiles = jetpack.find(sourcePath, { matching: '**/*' }) || [];
+    const targetFiles = jetpack.find(targetPath, { matching: '**/*' }) || [];
+
+    // Convert to relative paths for comparison
+    const sourceRelative = sourceFiles.map((f) => path.relative(sourcePath, f));
+    const targetRelative = targetFiles.map((f) => path.relative(targetPath, f));
+
+    // Find conflicts
+    const conflicts = sourceRelative.filter((file) => targetRelative.includes(file));
+
+    if (conflicts.length > 0) {
+      logger.warn(`Found ${conflicts.length} conflicting file(s):`);
+      conflicts.slice(0, 10).forEach((file) => logger.warn(`  - ${file}`));
+      if (conflicts.length > 10) {
+        logger.warn(`  ... and ${conflicts.length - 10} more`);
+      }
+      throw new Error('Cannot migrate assets: conflicts detected. Please resolve manually.');
+    }
+
+    // Move all files from source to target
+    logger.log('Moving files...');
+    sourceRelative.forEach((file) => {
+      const src = path.join(sourcePath, file);
+      const dest = path.join(targetPath, file);
+
+      // Only move files, not directories
+      if (jetpack.exists(src) === 'file') {
+        jetpack.move(src, dest);
+      }
+    });
+
+    // Remove the old assets directory
+    jetpack.remove(sourcePath);
+
+    logger.log(logger.format.green('✓ Successfully merged assets into src/assets'));
+  } else {
+    // Log the migration
+    logger.log(`Migrating assets from root to src/...`);
+    logger.log(`  Source: ${sourcePath}`);
+    logger.log(`  Target: ${targetPath}`);
+
+    // Ensure target directory parent exists
+    jetpack.dir(path.dirname(targetPath));
+
+    // Move the directory
+    jetpack.move(sourcePath, targetPath);
+
+    // Verify the move
+    const moveSuccessful = jetpack.exists(targetPath)
+      && !jetpack.exists(sourcePath);
+
+    if (moveSuccessful) {
+      logger.log(logger.format.green('✓ Successfully migrated assets to src/assets'));
+    } else {
+      throw new Error('Failed to migrate assets directory');
+    }
+  }
+}
+
+async function fixPostsLayout() {
+  const postsPath = path.join(process.cwd(), 'src', '_posts');
+
+  // Check if posts directory exists
+  const postsExists = jetpack.exists(postsPath);
+
+  if (!postsExists) {
+    logger.log('No src/_posts directory found - skipping layout fix');
+    return;
+  }
+
+  // Get all post files
+  const postFiles = jetpack.find(postsPath, {
+    matching: ['*.md', '*.html', '*.markdown'],
+  }) || [];
+
+  if (postFiles.length === 0) {
+    logger.log('No post files found in src/_posts - skipping layout fix');
+    return;
+  }
+
+  // Log
+  logger.log(`Fixing ${postFiles.length} post file(s)...`);
+
+  let updatedCount = 0;
+
+  // Process each post file
+  postFiles.forEach((file) => {
+    const content = jetpack.read(file);
+
+    if (!content) {
+      return;
+    }
+
+    // Match frontmatter
+    const frontmatterRegex = /^---\r?\n([\s\S]*?)\r?\n---/;
+    const match = content.match(frontmatterRegex);
+
+    if (!match) {
+      logger.warn(`  Skipping ${path.basename(file)} - no frontmatter found`);
+      return;
+    }
+
+    let frontmatter = match[1];
+    let restOfContent = content.slice(match[0].length);
+    let modified = false;
+
+    // 1. Fix layout if needed
+    if (!frontmatter.includes('layout: blueprint/blog/post')) {
+      frontmatter = frontmatter.replace(
+        /^layout:\s*.+$/m,
+        'layout: blueprint/blog/post'
+      );
+      modified = true;
+    }
+
+    // 2. Change excerpt to description
+    if (frontmatter.includes('excerpt:')) {
+      frontmatter = frontmatter.replace(
+        /^excerpt:/m,
+        'description:'
+      );
+      modified = true;
+    }
+
+    // 3. Remove affiliate-search-term line
+    if (frontmatter.includes('affiliate-search-term:')) {
+      frontmatter = frontmatter.replace(
+        /^affiliate-search-term:.*\r?\n/m,
+        ''
+      );
+      modified = true;
+    }
+
+    // 4. Remove ad unit includes from content
+    const adUnitRegex = /{%\s*include\s+\/master\/modules\/adunits\/adsense-in-article\.html\s+index="[^"]*"\s*%}/g;
+    const cleanedContent = restOfContent.replace(adUnitRegex, '');
+
+    if (cleanedContent !== restOfContent) {
+      restOfContent = cleanedContent;
+      modified = true;
+    }
+
+    // Only write if modifications were made
+    if (!modified) {
+      return;
+    }
+
+    // Write back to file
+    const updatedContent = `---\n${frontmatter}\n---${restOfContent}`;
+    jetpack.write(file, updatedContent);
+
+    updatedCount++;
+    logger.log(`  ✓ Updated ${path.basename(file)}`);
+  });
+
+  if (updatedCount > 0) {
+    logger.log(logger.format.green(`✓ Fixed ${updatedCount} post file(s)`));
+  } else {
+    logger.log('All posts are already up to date');
+  }
+}
+
+async function fixPostFilenames() {
+  const postsPath = path.join(process.cwd(), 'src', '_posts');
+
+  // Check if posts directory exists
+  const postsExists = jetpack.exists(postsPath);
+
+  if (!postsExists) {
+    logger.log('No src/_posts directory found - skipping filename fix');
+    return;
+  }
+
+  // Get all post files
+  const postFiles = jetpack.find(postsPath, {
+    matching: ['*.md', '*.html', '*.markdown'],
+  }) || [];
+
+  if (postFiles.length === 0) {
+    logger.log('No post files found in src/_posts - skipping filename fix');
+    return;
+  }
+
+  // Log
+  logger.log(`Checking post filenames for trailing and leading dashes...`);
+
+  let renamedCount = 0;
+
+  // Process each post file
+  postFiles.forEach((file) => {
+    const dir = path.dirname(file);
+    const basename = path.basename(file);
+    const ext = path.extname(basename);
+    const nameWithoutExt = basename.slice(0, -ext.length);
+
+    // Remove leading and trailing dashes only
+    const cleanedName = nameWithoutExt.replace(/^-+|-+$/g, '');
+
+    // Check if name changed
+    if (cleanedName === nameWithoutExt) {
+      return;
+    }
+
+    // Build new filename
+    const newFilename = `${cleanedName}${ext}`;
+    const newPath = path.join(dir, newFilename);
+
+    // Check if target already exists
+    if (jetpack.exists(newPath)) {
+      logger.warn(`  Cannot rename ${basename} - ${newFilename} already exists`);
+      return;
+    }
+
+    // Rename the file
+    jetpack.move(file, newPath);
+
+    renamedCount++;
+    logger.log(`  ✓ Renamed ${basename} → ${newFilename}`);
+  });
+
+  if (renamedCount > 0) {
+    logger.log(logger.format.green(`✓ Renamed ${renamedCount} post file(s)`));
+  } else {
+    logger.log('All post filenames are already clean');
+  }
+}

package/dist/commands/minify-html.js

@@ -0,0 +1,19 @@
+// Libraries
+const Manager = new (require('../build.js'));
+const logger = Manager.logger('minify');
+const { execute } = require('node-powertools');
+
+// Load package
+const package = Manager.getPackage('main');
+const project = Manager.getPackage('project');
+
+module.exports = async function (options) {
+  // Log
+  logger.log(`Starting minify...`);
+
+  // Build environment variables with all options
+  const envVars = `UJ_MINIFY_HTML_FORCE=true`;
+
+  // Run the full build process with minify force enabled
+  await execute(`${envVars} bundle exec npm run gulp -- minifyHtml`, { log: true })
+};

package/dist/defaults/dist/pages/test/libraries/error.html

@@ -0,0 +1,29 @@
+---
+### ALL PAGES ###
+layout: themes/[ site.theme.id ]/frontend/core/base
+permalink: /test/libraries/error
+
+### REGULAR PAGES ###
+meta:
+  title: "Error Test Page"
+  description: "Test page for demonstrating error handling"
+  breadcrumb: "Error Test"
+---
+
+<div class="container py-5">
+  <div class="row">
+    <div class="col-lg-8 mx-auto">
+      <h1 class="h2 mb-4">Error Test Page</h1>
+      <p class="lead mb-5">This page demonstrates different error handling scenarios.</p>
+
+      <!-- Trigger Auth Signin Error -->
+      <button id="trigger-error" class="btn btn-danger">Trigger Auth Signin Error</button>
+      <script>
+        document.getElementById('trigger-error').addEventListener('click', function() {
+          Manager.webManager.auth().signInWithEmailAndPassword('invalid@example.com', 'wrongpassword')
+        });
+      </script>
+
+    </div>
+  </div>
+</div>

package/dist/gulp/tasks/minifyHtml.js

@@ -2,7 +2,8 @@
 const Manager = new (require('../../build.js'));
 const logger = Manager.logger('minifyHtml');
 const { src, dest, series } = require('gulp');
-const { minify } = require('html-minifier-terser');
+const { minify: minifyRust } = require('@minify-html/node');
+const { minify: minifyJs } = require('terser');
 const through2 = require('through2');
 
 // Load package
@@ -19,6 +20,33 @@ const input = [
 ];
 const output = '_site';
 
+// Helper function to minify a single file's content using Rust-based minifier
+async function minifyFileContent(htmlContent, options, filePath) {
+  // Extract and temporarily replace JSON-LD scripts
+  const { content: contentAfterJsonLd, extracted: jsonLdScripts } = extractJsonLdScripts(htmlContent);
+
+  // Extract and temporarily replace inline scripts (minified with Terser)
+  const { content: contentAfterScripts, extracted: inlineScripts } = await extractInlineScripts(contentAfterJsonLd, filePath);
+
+  // Extract and temporarily replace IE conditional comments
+  const { content: contentAfterComments, extracted: conditionalComments } = extractConditionalComments(contentAfterScripts);
+
+  // Minify the HTML content using Rust-based minifier (synchronous, much faster)
+  const minifiedBuffer = minifyRust(Buffer.from(contentAfterComments), options);
+  const minified = minifiedBuffer.toString();
+
+  // Restore the conditional comments
+  let finalHtml = restoreConditionalComments(minified, conditionalComments);
+
+  // Restore the inline scripts
+  finalHtml = restoreInlineScripts(finalHtml, inlineScripts);
+
+  // Restore the JSON-LD scripts
+  finalHtml = restoreJsonLdScripts(finalHtml, jsonLdScripts);
+
+  return finalHtml;
+}
+
 // Main task
 function minifyHtmlTask(complete) {
   // Check if we should minify
@@ -33,92 +61,248 @@ function minifyHtmlTask(complete) {
   logger.log('Starting...');
   Manager.logMemory(logger, 'Start');
 
-  // Configure minify options
+  // Configure minify options for @minify-html/node (Rust-based)
+  // NOTE: Inline scripts are extracted before minification to avoid bugs in minify-js
   const options = {
-    collapseWhitespace: true,
-    removeComments: true,
-    removeAttributeQuotes: true,
-    removeRedundantAttributes: true,
-    removeScriptTypeAttributes: true,
-    removeStyleLinkTypeAttributes: true,
-    useShortDoctype: true,
-    removeEmptyAttributes: true,
-    removeOptionalTags: false,
-    minifyCSS: true,
-    minifyJS: true
+    keep_closing_tags: false,
+    keep_comments: false,
+    keep_html_and_head_opening_tags: false,
+    keep_spaces_between_attributes: false,
+    keep_ssi_comments: false,
+    minify_css: true,
+    minify_js: false, // Disabled - inline scripts are extracted, so nothing to minify
+    remove_bangs: false,
+    remove_processing_instructions: false
   };
 
+  // Get concurrency limit from environment or use default
+  const CONCURRENCY_LIMIT = parseInt(process.env.UJ_MINIFY_CONCURRENCY || '1', 10);
+  logger.log(`Concurrency: ${CONCURRENCY_LIMIT} files at a time`);
+
+  // Collect files for batch processing
+  const fileQueue = [];
+  const processed = { count: 0 };
+
   // Process HTML files
   return src(input)
-    .pipe(through2.obj(async function(file, enc, callback) {
+    .pipe(through2.obj(function(file, _enc, callback) {
       if (file.isBuffer()) {
-        try {
-          let htmlContent = file.contents.toString();
-
-          // Extract and temporarily replace JSON-LD scripts
-          const jsonLdScripts = [];
-          const jsonLdRegex = /<script[^>]*type=["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi;
-
-          htmlContent = htmlContent.replace(jsonLdRegex, (match, jsonContent) => {
-            // Minify the JSON content
-            try {
-              const parsed = JSON.parse(jsonContent);
-              const minifiedJson = JSON.stringify(parsed);
-              jsonLdScripts.push(minifiedJson);
-            } catch (e) {
-              jsonLdScripts.push(jsonContent);
-            }
-            return `__JSON_LD_PLACEHOLDER_${jsonLdScripts.length - 1}__`;
-          });
-
-          // Extract and temporarily replace IE conditional comments
-          const conditionalComments = [];
-          const conditionalRegex = /<!--\[if[^>]*\]>([\s\S]*?)<!\[endif\]-->/gi;
-
-          htmlContent = htmlContent.replace(conditionalRegex, (match, content) => {
-            // Minify the content inside the conditional comment
-            try {
-              const minifiedContent = content
-                .replace(/\s+/g, ' ')
-                .replace(/>\s+</g, '><')
-                .trim();
-              conditionalComments.push(match.replace(content, minifiedContent));
-            } catch (e) {
-              conditionalComments.push(match);
-            }
-            return `__CONDITIONAL_COMMENT_PLACEHOLDER_${conditionalComments.length - 1}__`;
-          });
-
-          // Minify the HTML content
-          const minified = await minify(htmlContent, options);
-
-          // Restore the JSON-LD scripts and conditional comments
-          let finalHtml = minified;
-          jsonLdScripts.forEach((jsonContent, index) => {
-            const scriptTag = `<script type=application/ld+json>${jsonContent}</script>`;
-            finalHtml = finalHtml.replace(`__JSON_LD_PLACEHOLDER_${index}__`, scriptTag);
-          });
-
-          conditionalComments.forEach((commentContent, index) => {
-            finalHtml = finalHtml.replace(`__CONDITIONAL_COMMENT_PLACEHOLDER_${index}__`, commentContent);
-          });
-
-          file.contents = Buffer.from(finalHtml);
-        } catch (err) {
-          logger.error(`Error minifying ${file.path}: ${err.message}`);
+        fileQueue.push({ file });
+        callback();
+      } else {
+        callback(null, file);
+      }
+    }, async function(callback) {
+      // This function is called when all files have been queued
+      if (fileQueue.length === 0) {
+        logger.log('No HTML files to minify');
+        return callback();
+      }
+
+      const totalFiles = fileQueue.length;
+      logger.log(`Minifying ${totalFiles} HTML files...`);
+
+      try {
+        // Process files in batches
+        for (let i = 0; i < fileQueue.length; i += CONCURRENCY_LIMIT) {
+          const batch = fileQueue.slice(i, i + CONCURRENCY_LIMIT);
+
+          // Process batch in parallel
+          const processedFiles = await Promise.all(
+            batch.map(async ({ file }) => {
+              try {
+                const htmlContent = file.contents.toString();
+                const finalHtml = await minifyFileContent(htmlContent, options, file.path);
+                file.contents = Buffer.from(finalHtml);
+                processed.count++;
+
+                // Log progress every 50 files or on last file
+                if (processed.count % 50 === 0 || processed.count === totalFiles) {
+                  const percentage = ((processed.count / totalFiles) * 100).toFixed(1);
+                  logger.log(`Progress: ${processed.count}/${totalFiles} files (${percentage}%)`);
+                  Manager.logMemory(logger, `After ${processed.count} files`);
+                }
+
+                return file;
+              } catch (err) {
+                logger.error(`Error minifying ${file.path}: ${err.message}`);
+                return file;
+              }
+            })
+          );
+
+          // Push processed files to the stream
+          processedFiles.forEach(file => this.push(file));
         }
+
+        callback();
+      } catch (err) {
+        logger.error(`Batch processing error: ${err.message}`);
+        callback(err);
       }
-      callback(null, file);
     }))
     .pipe(dest(output))
     .on('finish', () => {
       // Log
       logger.log('Finished!');
+      Manager.logMemory(logger, 'End');
 
       // Complete
-      return complete();
+      complete();
     });
 }
 
+// Helper: Extract JSON-LD scripts and replace with placeholders
+function extractJsonLdScripts(htmlContent) {
+  const extracted = [];
+  // Match both quoted and unquoted type attributes (minifier removes quotes)
+  const jsonLdRegex = /<script[^>]*type=(?:["']?application\/ld\+json["']?)[^>]*>([\s\S]*?)<\/script>/gi;
+
+  const content = htmlContent.replace(jsonLdRegex, (match, jsonContent) => {
+    // Minify the JSON content
+    try {
+      const parsed = JSON.parse(jsonContent);
+      const minifiedJson = JSON.stringify(parsed);
+      extracted.push(minifiedJson);
+    } catch (e) {
+      extracted.push(jsonContent);
+    }
+    return `__JSON_LD_PLACEHOLDER_${extracted.length - 1}__`;
+  });
+
+  return { content, extracted };
+}
+
+// Helper: Restore JSON-LD scripts from placeholders
+function restoreJsonLdScripts(htmlContent, jsonLdScripts) {
+  let content = htmlContent;
+
+  jsonLdScripts.forEach((jsonContent, index) => {
+    const scriptTag = `<script type=application/ld+json>${jsonContent}</script>`;
+    content = content.replace(`__JSON_LD_PLACEHOLDER_${index}__`, scriptTag);
+  });
+
+  return content;
+}
+
+// Helper: Extract inline scripts, minify with Terser, and replace with placeholders
+async function extractInlineScripts(htmlContent, filePath) {
+  const extracted = [];
+  const scripts = [];
+
+  // Match <script> tags that are NOT application/ld+json (those are already extracted)
+  // This regex excludes external scripts (those with src attribute)
+  // Handles both quoted and unquoted type attributes (minifier removes quotes)
+  const scriptRegex = /<script(?![^>]*type=(?:["']?application\/ld\+json["']?))(?![^>]*src=)([^>]*)>([\s\S]*?)<\/script>/gi;
+
+  // First pass: collect all scripts and create placeholders
+  const content = htmlContent.replace(scriptRegex, (fullMatch, attributes, jsCode) => {
+    const index = scripts.length;
+    scripts.push({ fullMatch, attributes, jsCode });
+    return `__INLINE_SCRIPT_PLACEHOLDER_${index}__`;
+  });
+
+  // Second pass: minify all scripts in parallel
+  const minifyPromises = scripts.map(async ({ fullMatch, attributes, jsCode }, scriptIndex) => {
+    // Skip empty scripts
+    if (!jsCode.trim()) {
+      return fullMatch;
+    }
+
+    // Try to minify the JavaScript with Terser
+    try {
+      const minified = await minifyJs(jsCode, {
+        compress: {
+          dead_code: true,
+          drop_console: false,
+          drop_debugger: true,
+          keep_classnames: false,
+          keep_fargs: true,
+          keep_fnames: false,
+          keep_infinity: false,
+        },
+        mangle: false, // Don't mangle variable names to avoid breaking code
+        format: {
+          comments: false,
+        },
+      });
+
+      if (minified && minified.code) {
+        return `<script${attributes}>${minified.code}</script>`;
+      }
+
+      return fullMatch;
+    } catch (err) {
+      // Minification failed - use original and log detailed error
+      const preview = jsCode.length > 100 ? jsCode.substring(0, 100) + '...' : jsCode;
+      const lines = jsCode.split('\n');
+
+      logger.error(`Failed to minify inline script in ${filePath}`);
+      logger.error(`  Script #${scriptIndex + 1} (${lines.length} lines)`);
+      logger.error(`  Error: ${err.message}`);
+
+      if (err.line !== undefined) {
+        logger.error(`  Line ${err.line}, Column ${err.col || '?'}`);
+      }
+
+      logger.error(`  Preview: ${preview.replace(/\n/g, ' ')}`);
+
+      return fullMatch;
+    }
+  });
+
+  // Wait for all minification to complete
+  const minifiedScripts = await Promise.all(minifyPromises);
+
+  // Add all minified scripts to extracted array
+  minifiedScripts.forEach(script => extracted.push(script));
+
+  return { content, extracted };
+}
+
+// Helper: Restore inline scripts from placeholders
+function restoreInlineScripts(htmlContent, inlineScripts) {
+  let content = htmlContent;
+
+  inlineScripts.forEach((scriptContent, index) => {
+    content = content.replace(`__INLINE_SCRIPT_PLACEHOLDER_${index}__`, scriptContent);
+  });
+
+  return content;
+}
+
+// Helper: Extract IE conditional comments and replace with placeholders
+function extractConditionalComments(htmlContent) {
+  const extracted = [];
+  const conditionalRegex = /<!--\[if[^>]*\]>([\s\S]*?)<!\[endif\]-->/gi;
+
+  const content = htmlContent.replace(conditionalRegex, (match, commentContent) => {
+    // Minify the content inside the conditional comment
+    try {
+      const minifiedContent = commentContent
+        .replace(/\s+/g, ' ')
+        .replace(/>\s+</g, '><')
+        .trim();
+      extracted.push(match.replace(commentContent, minifiedContent));
+    } catch (e) {
+      extracted.push(match);
+    }
+    return `__CONDITIONAL_COMMENT_PLACEHOLDER_${extracted.length - 1}__`;
+  });
+
+  return { content, extracted };
+}
+
+// Helper: Restore IE conditional comments from placeholders
+function restoreConditionalComments(htmlContent, conditionalComments) {
+  let content = htmlContent;
+
+  conditionalComments.forEach((commentContent, index) => {
+    content = content.replace(`__CONDITIONAL_COMMENT_PLACEHOLDER_${index}__`, commentContent);
+  });
+
+  return content;
+}
+
 // Default Task (no watcher for minifyHtml as it runs after Jekyll build)
 module.exports = minifyHtmlTask;

package/dist/gulp/tasks/translation.js

@@ -82,6 +82,11 @@ let index = -1;
 const input = [
   // Files to include
   '_site/**/*.html',
+
+  // Files to exclude
+  // Test pages (except translation.html)
+  '!_site/**/test/**',
+  '_site/test/translation.html',
 ];
 const output = '';
 const delay = 250;

package/dist/gulp/tasks/utils/BU/minifyHtml.js

@@ -0,0 +1,183 @@
+// Libraries
+const Manager = new (require('../../build.js'));
+const logger = Manager.logger('minifyHtml');
+const { src, dest, series } = require('gulp');
+const { minify } = require('html-minifier-terser');
+const through2 = require('through2');
+
+// Load package
+const package = Manager.getPackage('main');
+const project = Manager.getPackage('project');
+const config = Manager.getConfig('project');
+const rootPathPackage = Manager.getRootPath('main');
+const rootPathProject = Manager.getRootPath('project');
+
+// Glob
+const input = [
+  // Files to include
+  '_site/**/*.html',
+];
+const output = '_site';
+
+// Helper function to minify a single file's content
+async function minifyFileContent(htmlContent, options) {
+  // Extract and temporarily replace JSON-LD scripts
+  const jsonLdScripts = [];
+  const jsonLdRegex = /<script[^>]*type=["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi;
+
+  htmlContent = htmlContent.replace(jsonLdRegex, (match, jsonContent) => {
+    // Minify the JSON content
+    try {
+      const parsed = JSON.parse(jsonContent);
+      const minifiedJson = JSON.stringify(parsed);
+      jsonLdScripts.push(minifiedJson);
+    } catch (e) {
+      jsonLdScripts.push(jsonContent);
+    }
+    return `__JSON_LD_PLACEHOLDER_${jsonLdScripts.length - 1}__`;
+  });
+
+  // Extract and temporarily replace IE conditional comments
+  const conditionalComments = [];
+  const conditionalRegex = /<!--\[if[^>]*\]>([\s\S]*?)<!\[endif\]-->/gi;
+
+  htmlContent = htmlContent.replace(conditionalRegex, (match, content) => {
+    // Minify the content inside the conditional comment
+    try {
+      const minifiedContent = content
+        .replace(/\s+/g, ' ')
+        .replace(/>\s+</g, '><')
+        .trim();
+      conditionalComments.push(match.replace(content, minifiedContent));
+    } catch (e) {
+      conditionalComments.push(match);
+    }
+    return `__CONDITIONAL_COMMENT_PLACEHOLDER_${conditionalComments.length - 1}__`;
+  });
+
+  // Minify the HTML content
+  const minified = await minify(htmlContent, options);
+
+  // Restore the JSON-LD scripts and conditional comments
+  let finalHtml = minified;
+  jsonLdScripts.forEach((jsonContent, index) => {
+    const scriptTag = `<script type=application/ld+json>${jsonContent}</script>`;
+    finalHtml = finalHtml.replace(`__JSON_LD_PLACEHOLDER_${index}__`, scriptTag);
+  });
+
+  conditionalComments.forEach((commentContent, index) => {
+    finalHtml = finalHtml.replace(`__CONDITIONAL_COMMENT_PLACEHOLDER_${index}__`, commentContent);
+  });
+
+  return finalHtml;
+}
+
+// Helper function to process files in batches
+async function processBatch(batch, options, processed, total) {
+  return Promise.all(batch.map(async ({ file }) => {
+    try {
+      const htmlContent = file.contents.toString();
+      const finalHtml = await minifyFileContent(htmlContent, options);
+      file.contents = Buffer.from(finalHtml);
+      processed.count++;
+
+      // Log progress every 10 files or on last file
+      if (processed.count % 10 === 0 || processed.count === total) {
+        const percentage = ((processed.count / total) * 100).toFixed(1);
+        logger.log(`Progress: ${processed.count}/${total} files (${percentage}%)`);
+        Manager.logMemory(logger, `After ${processed.count} files`);
+      }
+
+      return file;
+    } catch (err) {
+      logger.error(`Error minifying ${file.path}: ${err.message}`);
+      return file;
+    }
+  }));
+}
+
+// Main task
+function minifyHtmlTask(complete) {
+  // Check if we should minify
+  const shouldMinify = Manager.isBuildMode() || process.env.UJ_MINIFY_HTML_FORCE === 'true';
+
+  if (!shouldMinify) {
+    logger.log('Skipping HTML minification (not in production mode and UJ_MINIFY_HTML_FORCE not set)');
+    return complete();
+  }
+
+  // Get concurrency limit from environment or use default
+  const CONCURRENCY_LIMIT = parseInt(process.env.UJ_MINIFY_CONCURRENCY || '10', 10);
+
+  // Log
+  logger.log('Starting...');
+  logger.log(`Concurrency limit: ${CONCURRENCY_LIMIT} files at a time`);
+  Manager.logMemory(logger, 'Start');
+
+  // Configure minify options
+  const options = {
+    collapseWhitespace: true,
+    removeComments: true,
+    removeAttributeQuotes: true,
+    removeRedundantAttributes: true,
+    removeScriptTypeAttributes: true,
+    removeStyleLinkTypeAttributes: true,
+    useShortDoctype: true,
+    removeEmptyAttributes: true,
+    removeOptionalTags: false,
+    minifyCSS: true,
+    minifyJS: true
+  };
+
+  // Collect files for batch processing
+  const fileQueue = [];
+  const processed = { count: 0 };
+
+  // Process HTML files
+  return src(input)
+    .pipe(through2.obj(function(file, _enc, callback) {
+      if (file.isBuffer()) {
+        fileQueue.push({ file });
+        callback();
+      } else {
+        callback(null, file);
+      }
+    }, async function(callback) {
+      // This function is called when all files have been queued
+      if (fileQueue.length === 0) {
+        logger.log('No HTML files to minify');
+        return callback();
+      }
+
+      const totalFiles = fileQueue.length;
+      logger.log(`Minifying ${totalFiles} HTML files...`);
+
+      try {
+        // Process files in batches
+        for (let i = 0; i < fileQueue.length; i += CONCURRENCY_LIMIT) {
+          const batch = fileQueue.slice(i, i + CONCURRENCY_LIMIT);
+          const processedFiles = await processBatch(batch, options, processed, totalFiles);
+
+          // Push processed files to the stream
+          processedFiles.forEach(file => this.push(file));
+        }
+
+        callback();
+      } catch (err) {
+        logger.error(`Batch processing error: ${err.message}`);
+        callback(err);
+      }
+    }))
+    .pipe(dest(output))
+    .on('finish', () => {
+      // Log
+      logger.log('Finished!');
+      Manager.logMemory(logger, 'End');
+
+      // Complete
+      complete();
+    });
+}
+
+// Default Task (no watcher for minifyHtml as it runs after Jekyll build)
+module.exports = minifyHtmlTask;

package/dist/gulp/tasks/utils/BU/minifyHtml.worker.js

@@ -0,0 +1,72 @@
+// Worker thread for HTML minification
+const { parentPort, workerData } = require('worker_threads');
+const { minify } = require('html-minifier-terser');
+
+// Listen for messages from parent
+parentPort.on('message', async (data) => {
+  const { htmlContent, options, index } = data;
+
+  try {
+    // Extract and temporarily replace JSON-LD scripts
+    const jsonLdScripts = [];
+    const jsonLdRegex = /<script[^>]*type=["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi;
+
+    let processedContent = htmlContent.replace(jsonLdRegex, (match, jsonContent) => {
+      // Minify the JSON content
+      try {
+        const parsed = JSON.parse(jsonContent);
+        const minifiedJson = JSON.stringify(parsed);
+        jsonLdScripts.push(minifiedJson);
+      } catch (e) {
+        jsonLdScripts.push(jsonContent);
+      }
+      return `__JSON_LD_PLACEHOLDER_${jsonLdScripts.length - 1}__`;
+    });
+
+    // Extract and temporarily replace IE conditional comments
+    const conditionalComments = [];
+    const conditionalRegex = /<!--\[if[^>]*\]>([\s\S]*?)<!\[endif\]-->/gi;
+
+    processedContent = processedContent.replace(conditionalRegex, (match, content) => {
+      // Minify the content inside the conditional comment
+      try {
+        const minifiedContent = content
+          .replace(/\s+/g, ' ')
+          .replace(/>\s+</g, '><')
+          .trim();
+        conditionalComments.push(match.replace(content, minifiedContent));
+      } catch (e) {
+        conditionalComments.push(match);
+      }
+      return `__CONDITIONAL_COMMENT_PLACEHOLDER_${conditionalComments.length - 1}__`;
+    });
+
+    // Minify the HTML content
+    const minified = await minify(processedContent, options);
+
+    // Restore the JSON-LD scripts and conditional comments
+    let finalHtml = minified;
+    jsonLdScripts.forEach((jsonContent, idx) => {
+      const scriptTag = `<script type=application/ld+json>${jsonContent}</script>`;
+      finalHtml = finalHtml.replace(`__JSON_LD_PLACEHOLDER_${idx}__`, scriptTag);
+    });
+
+    conditionalComments.forEach((commentContent, idx) => {
+      finalHtml = finalHtml.replace(`__CONDITIONAL_COMMENT_PLACEHOLDER_${idx}__`, commentContent);
+    });
+
+    // Send result back to parent
+    parentPort.postMessage({
+      success: true,
+      index,
+      result: finalHtml
+    });
+  } catch (err) {
+    // Send error back to parent
+    parentPort.postMessage({
+      success: false,
+      index,
+      error: err.message
+    });
+  }
+});

package/dist/gulp/tasks/webpack.js

@@ -104,7 +104,11 @@ function getSettings() {
         ? DEFAULT_WEBPACK_TARGET
         : (ujmConfig?.webpack?.target || DEFAULT_WEBPACK_TARGET)
     ],
-    devtool: Manager.actLikeProduction() ? 'source-map' : 'eval-source-map',
+    // devtool: Manager.actLikeProduction() ? 'source-map' : 'eval-source-map',
+    // Production: nosources-source-map, hidden-source-map
+    devtool: Manager.actLikeProduction() ? false : 'eval-source-map',
+    // devtool: 'nosources-source-map',
+    // devtool: 'source-map',
     // devtool: false,
     plugins: [
       new StripDevBlocksPlugin(),
@@ -213,7 +217,8 @@ function getSettings() {
           use: {
             loader: 'babel-loader',
             options: {
-              sourceMaps: true,
+                // sourceMaps: false,
+                sourceMaps: !Manager.actLikeProduction(),
               presets: [
                 [require.resolve('@babel/preset-env', {
                   paths: [path.resolve(process.cwd(), 'node_modules', package.name, 'node_modules')]
@@ -319,7 +324,8 @@ function webpack(complete) {
             use: {
               loader: 'babel-loader',
               options: {
-                sourceMaps: true,
+                // sourceMaps: false,
+                sourceMaps: !Manager.actLikeProduction(),
                 presets: [
                   [require.resolve('@babel/preset-env', {
                     paths: [path.resolve(process.cwd(), 'node_modules', package.name, 'node_modules')]

package/firebase-debug.log

@@ -54,3 +54,35 @@
 [debug] [2025-10-22T06:51:09.274Z] > authorizing via signed-in user (ian.wiedenman@gmail.com)
 [debug] [2025-10-22T06:51:09.274Z] > command requires scopes: ["email","openid","https://www.googleapis.com/auth/cloudplatformprojects.readonly","https://www.googleapis.com/auth/firebase","https://www.googleapis.com/auth/cloud-platform"]
 [debug] [2025-10-22T06:51:09.274Z] > authorizing via signed-in user (ian.wiedenman@gmail.com)
+[debug] [2025-10-22T08:40:01.642Z] > command requires scopes: ["email","openid","https://www.googleapis.com/auth/cloudplatformprojects.readonly","https://www.googleapis.com/auth/firebase","https://www.googleapis.com/auth/cloud-platform"]
+[debug] [2025-10-22T08:40:01.642Z] > command requires scopes: ["email","openid","https://www.googleapis.com/auth/cloudplatformprojects.readonly","https://www.googleapis.com/auth/firebase","https://www.googleapis.com/auth/cloud-platform"]
+[debug] [2025-10-22T08:40:01.644Z] > authorizing via signed-in user (ian.wiedenman@gmail.com)
+[debug] [2025-10-22T08:40:01.644Z] > command requires scopes: ["email","openid","https://www.googleapis.com/auth/cloudplatformprojects.readonly","https://www.googleapis.com/auth/firebase","https://www.googleapis.com/auth/cloud-platform"]
+[debug] [2025-10-22T08:40:01.644Z] > authorizing via signed-in user (ian.wiedenman@gmail.com)
+[debug] [2025-10-22T08:40:01.644Z] > authorizing via signed-in user (ian.wiedenman@gmail.com)
+[debug] [2025-10-22T08:40:01.644Z] > command requires scopes: ["email","openid","https://www.googleapis.com/auth/cloudplatformprojects.readonly","https://www.googleapis.com/auth/firebase","https://www.googleapis.com/auth/cloud-platform"]
+[debug] [2025-10-22T08:40:01.644Z] > authorizing via signed-in user (ian.wiedenman@gmail.com)
+[debug] [2025-10-22T09:43:23.845Z] > command requires scopes: ["email","openid","https://www.googleapis.com/auth/cloudplatformprojects.readonly","https://www.googleapis.com/auth/firebase","https://www.googleapis.com/auth/cloud-platform"]
+[debug] [2025-10-22T09:43:23.848Z] > authorizing via signed-in user (ian.wiedenman@gmail.com)
+[debug] [2025-10-22T09:43:23.848Z] > command requires scopes: ["email","openid","https://www.googleapis.com/auth/cloudplatformprojects.readonly","https://www.googleapis.com/auth/firebase","https://www.googleapis.com/auth/cloud-platform"]
+[debug] [2025-10-22T09:43:23.848Z] > authorizing via signed-in user (ian.wiedenman@gmail.com)
+[debug] [2025-10-22T09:43:23.847Z] > command requires scopes: ["email","openid","https://www.googleapis.com/auth/cloudplatformprojects.readonly","https://www.googleapis.com/auth/firebase","https://www.googleapis.com/auth/cloud-platform"]
+[debug] [2025-10-22T09:43:23.853Z] > authorizing via signed-in user (ian.wiedenman@gmail.com)
+[debug] [2025-10-22T09:43:23.853Z] > command requires scopes: ["email","openid","https://www.googleapis.com/auth/cloudplatformprojects.readonly","https://www.googleapis.com/auth/firebase","https://www.googleapis.com/auth/cloud-platform"]
+[debug] [2025-10-22T09:43:23.854Z] > authorizing via signed-in user (ian.wiedenman@gmail.com)
+[debug] [2025-10-22T10:05:29.839Z] > command requires scopes: ["email","openid","https://www.googleapis.com/auth/cloudplatformprojects.readonly","https://www.googleapis.com/auth/firebase","https://www.googleapis.com/auth/cloud-platform"]
+[debug] [2025-10-22T10:05:29.841Z] > authorizing via signed-in user (ian.wiedenman@gmail.com)
+[debug] [2025-10-22T10:05:29.841Z] > command requires scopes: ["email","openid","https://www.googleapis.com/auth/cloudplatformprojects.readonly","https://www.googleapis.com/auth/firebase","https://www.googleapis.com/auth/cloud-platform"]
+[debug] [2025-10-22T10:05:29.841Z] > authorizing via signed-in user (ian.wiedenman@gmail.com)
+[debug] [2025-10-22T10:05:29.842Z] > command requires scopes: ["email","openid","https://www.googleapis.com/auth/cloudplatformprojects.readonly","https://www.googleapis.com/auth/firebase","https://www.googleapis.com/auth/cloud-platform"]
+[debug] [2025-10-22T10:05:29.844Z] > authorizing via signed-in user (ian.wiedenman@gmail.com)
+[debug] [2025-10-22T10:05:29.844Z] > command requires scopes: ["email","openid","https://www.googleapis.com/auth/cloudplatformprojects.readonly","https://www.googleapis.com/auth/firebase","https://www.googleapis.com/auth/cloud-platform"]
+[debug] [2025-10-22T10:05:29.844Z] > authorizing via signed-in user (ian.wiedenman@gmail.com)
+[debug] [2025-10-22T10:35:12.194Z] > command requires scopes: ["email","openid","https://www.googleapis.com/auth/cloudplatformprojects.readonly","https://www.googleapis.com/auth/firebase","https://www.googleapis.com/auth/cloud-platform"]
+[debug] [2025-10-22T10:35:12.196Z] > command requires scopes: ["email","openid","https://www.googleapis.com/auth/cloudplatformprojects.readonly","https://www.googleapis.com/auth/firebase","https://www.googleapis.com/auth/cloud-platform"]
+[debug] [2025-10-22T10:35:12.197Z] > authorizing via signed-in user (ian.wiedenman@gmail.com)
+[debug] [2025-10-22T10:35:12.197Z] > command requires scopes: ["email","openid","https://www.googleapis.com/auth/cloudplatformprojects.readonly","https://www.googleapis.com/auth/firebase","https://www.googleapis.com/auth/cloud-platform"]
+[debug] [2025-10-22T10:35:12.197Z] > authorizing via signed-in user (ian.wiedenman@gmail.com)
+[debug] [2025-10-22T10:35:12.198Z] > authorizing via signed-in user (ian.wiedenman@gmail.com)
+[debug] [2025-10-22T10:35:12.198Z] > command requires scopes: ["email","openid","https://www.googleapis.com/auth/cloudplatformprojects.readonly","https://www.googleapis.com/auth/firebase","https://www.googleapis.com/auth/cloud-platform"]
+[debug] [2025-10-22T10:35:12.198Z] > authorizing via signed-in user (ian.wiedenman@gmail.com)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ultimate-jekyll-manager",
-  "version": "0.0.93",
+  "version": "0.0.95",
   "description": "Ultimate Jekyll dependency manager",
   "main": "dist/index.js",
   "exports": {
@@ -62,6 +62,7 @@
     "@babel/core": "^7.28.4",
     "@babel/preset-env": "^7.28.3",
     "@fullhuman/postcss-purgecss": "^7.0.2",
+    "@minify-html/node": "^0.16.4",
     "@octokit/rest": "^22.0.0",
     "@popperjs/core": "^2.11.8",
     "@prettier/plugin-xml": "^3.4.2",