portosaurus 1.14.0

package/internal/src/utils/generateFavicon.js

@@ -0,0 +1,256 @@
+const fs = require('fs');
+const path = require('path');
+
+const { favicons } = require('favicons');
+const { downloadImage } = require('./imageDownloader');
+const { reshapeImage } = require('./imageProcessor');
+const { getCssVar } = require('./cssUtils');
+const { extractSvg } = require('./iconExtractor');
+
+function createDirectoryIfNotExists(dir) {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+    return true;
+  }
+  return false;
+}
+
+function cleanupFile(filePath) {
+  if (fs.existsSync(filePath)) {
+    try { 
+      fs.unlinkSync(filePath); 
+      return true;
+    } catch (e) {
+      console.warn(`[WARNING] Failed to clean up file ${filePath}:`, e.message);
+    }
+  }
+  return false;
+}
+
+function processManifest(manifestFile, outputDir, appVersion) {
+  try {
+    const manifest = JSON.parse(manifestFile.contents);
+    manifest.version = appVersion;
+    
+    fs.writeFileSync(
+      path.join(outputDir, manifestFile.name), 
+      JSON.stringify(manifest, null, 2)
+    );
+    return true;
+  } catch (err) {
+    console.error('[ERROR] Failed to process manifest:', err.message);
+    fs.writeFileSync(path.join(outputDir, manifestFile.name), manifestFile.contents);
+    return false;
+  }
+}
+
+async function generateFavicons(context, options = {}) {
+  console.log('\n[INFO] Generating favicons...');
+  
+  const {siteConfig} = context;
+  const profilePicUrl = options.imagePath || siteConfig.customFields.heroSection.profilePic;
+  const appVersion = siteConfig.customFields.version || '1.0';
+  const circular = options.circular !== false;
+  const shape = options.shape || 'circle';
+  
+  const staticBaseDir = path.resolve(context.siteDir, 'static');
+  const imgDir = path.join(staticBaseDir, 'img', 'svg');
+  const imgStaticPath = '/img/svg'; 
+  const outputDir = path.join(staticBaseDir, options.outputPath || 'favicon');
+  
+  const tempDir = path.resolve(context.siteDir);
+  const reshapedImagePath = path.join(tempDir, 'temp_reshaped_pic.png');
+  
+  const tempFiles = [];
+  
+  try {
+    const iconColor = { color: getCssVar('--ifm-color-primary') };
+    const iconsToGenerate = ['note', 'blog'];
+    
+    for (const icon of iconsToGenerate) {
+      await extractSvg(icon, imgDir, iconColor);
+    }
+
+    const configuration = {
+      path: `/${options.outputPath || 'favicon'}/`,
+      appName: siteConfig.title || 'Portfolio',
+      appDescription: siteConfig.tagline || 'Portfolio',
+      background: getCssVar('--ifm-background-color'),
+      theme_color: getCssVar('--ifm-color-primary'),
+      appleStatusBarStyle: 'black-translucent',
+      display: 'standalone',
+      scope: '/',
+      start_url: '/',
+      version: appVersion,
+      orientation: 'natural',
+      logging: false,
+      loadManifestWithCredentials: true,
+      manifestMaskable: true,
+      icons: {
+        android: {
+          offset: 0,
+          background: false,
+          mask: true,
+          overlayGlow: false,
+          androidPlayStore: true,
+        },
+        favicons: true,
+        appleIcon: true,
+        appleStartup: false,
+        windows: false,
+        yandex: false,
+      },
+      shortcuts: [
+        {
+          name: "Notes",
+          short_name: "Notes",
+          description: "View my collection of notes",
+          url: "/notes",
+          icons: [
+            { 
+              src: `${imgStaticPath}/icon-note.svg`,
+              sizes: "any",
+              type: "image/svg+xml",
+              purpose: "any" 
+            },
+            { 
+              src: "/img/project-blank.png", 
+              sizes: "192x192", 
+              type: "image/png",
+              purpose: "any"
+            }
+          ]
+        },
+        {
+          name: "Blog",
+          short_name: "Blog",
+          description: "Read my latest blog posts",
+          url: "/blog",
+          icons: [
+            { 
+              src: `${imgStaticPath}/icon-blog.svg`,
+              sizes: "any",
+              type: "image/svg+xml",
+              purpose: "any" 
+            },
+            { 
+              src: "/favicon/android-chrome-192x192.png", 
+              sizes: "192x192", 
+              type: "image/png",
+              purpose: "any"
+            }
+          ]
+        }
+      ]
+    };
+    
+    const downloadedImage = await downloadImage(profilePicUrl, context.siteDir, 'temp_profile_pic.png');
+
+    tempFiles.push(downloadedImage);
+    
+    let finalImagePath = downloadedImage;
+    if (circular) {
+      finalImagePath = await reshapeImage(downloadedImage, reshapedImagePath, shape);
+      tempFiles.push(finalImagePath);
+      cleanupFile(downloadedImage);
+    }
+    
+    createDirectoryIfNotExists(outputDir);
+    
+    console.log(`[INFO] Generating favicon assets from ${finalImagePath}`);
+    const response = await favicons(finalImagePath, configuration);
+    
+    let imageCount = 0, fileCount = 0;
+    
+    if (Array.isArray(response.images) && response.images.length > 0) {
+      for (const image of response.images) {
+        if (!image || !image.name || !image.contents) continue;
+        
+        try {
+          fs.writeFileSync(path.join(outputDir, image.name), image.contents);
+          imageCount++;
+        } catch (err) {
+          console.error(`[ERROR] Failed to write image ${image.name}:`, err.message);
+        }
+      }
+    }
+    
+    if (Array.isArray(response.files) && response.files.length > 0) {
+      for (const file of response.files) {
+        if (!file || !file.name || !file.contents) continue;
+        
+        try {
+          if (file.name.includes('manifest')) {
+            processManifest(file, outputDir, appVersion);
+          } else {
+            fs.writeFileSync(path.join(outputDir, file.name), file.contents);
+          }
+          fileCount++;
+        } catch (err) {
+          console.error(`[ERROR] Failed to write file ${file.name}:`, err.message);
+        }
+      }
+    }
+    
+    tempFiles.forEach(cleanupFile);
+    
+    console.log(`[SUCCESS] Generated ${imageCount} favicon images and ${fileCount} support files\n`);
+    return true;
+    
+  } catch (error) {
+    console.error('[ERROR] Error generating favicons:', error.message);
+    tempFiles.forEach(cleanupFile);
+    throw error;
+  }
+}
+
+module.exports = {
+  generateFavicons,
+  default: function(context, options = {}) {
+    const {
+      imagePath = null,
+      outputPath = 'favicon',
+      circular = true,
+      shape = 'circle',
+      generateOnDev = true,
+    } = options;
+
+    return {
+      name: 'favicon-generator',
+      
+      async loadContent() {
+        const shouldGenerate = 
+          process.env.NODE_ENV === 'production' || 
+          process.env.GENERATE_FAVICONS || 
+          generateOnDev;
+          
+        if (shouldGenerate) {
+          try {
+            await generateFavicons(context, {
+              imagePath,
+              outputPath,
+              circular,
+              shape,
+            });
+          } catch (error) {
+            console.error('[FATAL] Favicon generation failed:', error);
+            process.exit(1);
+          }
+        }
+      }
+    };
+  }
+};
+
+if (require.main === module) {
+  const siteDir = path.resolve(__dirname, '../..');
+  const siteConfig = require('../../docusaurus.config.js').default;
+  
+  generateFavicons({
+    siteDir,
+    siteConfig
+  }).catch(error => {
+    console.error('[FATAL] Error in CLI mode:', error);
+    process.exit(1);
+  });
+}

package/internal/src/utils/generateRobotsTxt.js

@@ -0,0 +1,97 @@
+const path = require('path');
+const fs = require('fs');
+
+
+function formatRules(rules) {
+  if (!Array.isArray(rules) || !rules.length) return '';
+  
+  let content = '';
+  
+  rules.forEach(rule => {
+
+    // Default userAgent to '*' if not specified
+    const userAgent = rule.userAgent || '*';
+    
+    content += `User-agent: ${userAgent}\n`;
+    
+    // Check if root path is explicitly disallowed
+    const disallowsRoot = Array.isArray(rule.disallow) && 
+      rule.disallow.some(path => path === '/' || path === '/*');
+    
+    // Process allow directives
+    if (Array.isArray(rule.allow) && rule.allow.length > 0) {
+
+      // Use explicitly defined allow rules
+      for (const allowPath of rule.allow) {
+        content += `Allow: ${allowPath}\n`;
+      }
+
+    } else if (!disallowsRoot) {
+      content += `Allow: /\n`;
+    }
+    
+    // Process disallow directives
+    if (Array.isArray(rule.disallow)) {
+      for (const disallowPath of rule.disallow) {
+        content += `Disallow: ${disallowPath}\n`;
+      }
+    }
+    
+    content += '\n';
+  });
+  
+  return content;
+}
+
+
+module.exports = function() {
+  return {
+    name: 'generate-robots-txt',
+    
+    async postBuild({ outDir, siteConfig }) {
+      const robotsConfig = siteConfig.customFields?.robotsTxt;
+      
+      // Early return if robots.txt is disabled
+      if (!robotsConfig || robotsConfig.enable === false) {
+        console.log('ℹ️ robots.txt generation is disabled in config');
+        return;
+      }
+      
+      try {
+        const robotsTxtPath = path.join(outDir, 'robots.txt');
+        let content = '';
+        
+        // Process the rules structure
+        if (robotsConfig.rules) {
+          content += formatRules(robotsConfig.rules);
+        }
+        
+        // Always include sitemap reference
+        content += `Sitemap: ${siteConfig.url}/sitemap.xml\n`;
+        
+        if (Array.isArray(robotsConfig.customLines) && robotsConfig.customLines.length) {
+
+          const filteredCustomLines = robotsConfig.customLines.filter(
+            line => !line.trim().toLowerCase().startsWith('sitemap:')
+          );
+          
+          if (filteredCustomLines.length > 0) {
+            content += filteredCustomLines.join('\n') + '\n';
+          }
+        }
+        
+        // Only write file if we have content
+        if (content) {
+          fs.writeFileSync(robotsTxtPath, content, 'utf8');
+          console.log('✅ robots.txt generated successfully');
+
+        } else {
+          console.warn('⚠️ Warning: No robots.txt rules defined in config');
+        }
+
+      } catch (error) {
+        console.error('❌ Error generating robots.txt:', error);
+      }
+    }
+  };
+};

package/internal/src/utils/iconExtractor.js

@@ -0,0 +1,159 @@
+const fs = require('fs');
+const path = require('path');
+const React = require('react');
+const ReactDOMServer = require('react-dom/server');
+const { iconMap } = require('../config/iconMappings');
+
+/// AI Generated
+
+/**
+ * Dynamically requires a React Icon
+ * @param {string} iconPath - Path in format "package/IconName" (e.g., "ai/AiFillAlert")
+ * @returns {Object|null} The icon component or null if not found
+ */
+function requireDynamicIcon(iconPath) {
+  try {
+    const [packageName, iconName] = iconPath.split('/');
+    
+    if (packageName && iconName) {
+      const iconPackage = require(`react-icons/${packageName}`);
+      return iconPackage[iconName];
+    }
+    return null;
+  } catch (error) {
+    console.error(`Failed to import icon ${iconPath}:`, error.message);
+    return null;
+  }
+}
+
+/**
+ * Cleans SVG string to create a properly formatted standalone SVG file
+ * @param {string} svgString - The SVG string from ReactDOMServer
+ * @param {string} color - The color to apply to the SVG
+ * @returns {string} Clean SVG content
+ */
+function cleanSvgString(svgString, color) {
+
+  // Remove React-specific attributes and add proper XML declaration
+  let cleanedSvg = svgString
+    .replace(/<!--.*?-->/g, '') // Remove comments
+    .replace(/stroke="currentColor"/g, `stroke="${color}"`)
+    .replace(/fill="currentColor"/g, `fill="${color}"`);
+
+  // Add XML declaration if not present
+  if (!cleanedSvg.includes('<?xml')) {
+    cleanedSvg = `<?xml version="1.0" encoding="UTF-8" standalone="no"?>\n${cleanedSvg}`;
+  }
+
+  // Add viewBox if not present
+  if (!cleanedSvg.includes('viewBox')) {
+    cleanedSvg = cleanedSvg.replace('<svg', '<svg viewBox="0 0 24 24"');
+  }
+
+  return cleanedSvg;
+}
+
+/**
+ * Extracts SVG content from a React Icon component and saves it to a file
+ * 
+ * @param {React.ComponentType|string} icon - Icon component, name from iconMap, or path like "ai/AiFillAlert"
+ * @param {string} outputPath - Path to save the SVG file, defaults to static/img/svg if not provided
+ * @param {object} options - Additional options
+ * @param {string} options.color - Icon color (default: 'white')
+ * @param {number} options.size - Icon size (default: 24)
+ * @param {string} options.filename - Override filename (default: icon-<name>.svg)
+ * @param {string} options.iconName - Specify icon name instead of using component name
+ * @returns {string} The path to the saved SVG file
+ */
+function extractSvg(icon, outputPath = null, options = {}) {
+
+  // Default output path
+  if (!outputPath) {
+    outputPath = path.join(path.resolve(__dirname, '../..'), 'static', 'img', 'svg');
+  }
+
+  // Ensure the base output directory exists
+  const baseOutputDir = typeof outputPath === 'string' && !path.extname(outputPath) 
+    ? outputPath 
+    : path.dirname(outputPath);
+    
+  if (!fs.existsSync(baseOutputDir)) {
+    fs.mkdirSync(baseOutputDir, { recursive: true });
+    console.log(`[INFO] Created directory: ${baseOutputDir}`);
+  }
+
+  // Resolve icon component
+  let IconComponent = icon;
+  let iconIdentifier = null;
+  
+  if (typeof icon === 'string') {
+
+    if (icon.includes('/')) {
+
+      // ("ai/AiFillAlert")
+      IconComponent = requireDynamicIcon(icon);
+      iconIdentifier = icon.split('/')[1];
+
+    } else {
+
+      // Icon from the iconMap
+      IconComponent = iconMap[icon.toLowerCase()]?.icon;
+      iconIdentifier = icon;
+    }
+    
+    if (!IconComponent) {
+      throw new Error(`Icon "${icon}" could not be resolved`);
+    }
+    
+    // Use identifier if iconName not specified
+    if (!options.iconName && iconIdentifier) {
+      options.iconName = iconIdentifier;
+    }
+  }
+  
+  const { color = 'white', size = 24, filename = null, iconName = null } = options;
+  
+  // Determine final output path
+  const pathStats = fs.existsSync(outputPath) ? fs.statSync(outputPath) : null;
+  const isDirectory = pathStats ? pathStats.isDirectory() : false;
+  
+  if (isDirectory || filename) {
+    const baseDir = isDirectory ? outputPath : path.dirname(outputPath);
+    
+    // Create directory if needed
+    if (!fs.existsSync(baseDir)) {
+      fs.mkdirSync(baseDir, { recursive: true });
+    }
+    
+    // Generate filename if not provided
+    const componentName = iconName || IconComponent.name;
+    const finalFilename = filename || `icon-${componentName}.svg`;
+    outputPath = path.join(baseDir, finalFilename);
+  }
+  
+  // Create and render the icon
+  const element = React.createElement(IconComponent, { 
+    color, 
+    size,
+    style: { color }
+  });
+  
+  // Render the React element to an HTML string and clean it
+  const svgString = ReactDOMServer.renderToStaticMarkup(element);
+  const cleanedSvg = cleanSvgString(svgString, color);
+  
+  // Ensure final output path exists
+  const finalDir = path.dirname(outputPath);
+
+  if (!fs.existsSync(finalDir)) {
+    fs.mkdirSync(finalDir, { recursive: true });
+  }
+  
+  // Write to file
+  fs.writeFileSync(outputPath, cleanedSvg);
+  console.log(`[INFO] Generated SVG icon: ${outputPath}`);
+  
+  return outputPath;
+}
+
+module.exports = { extractSvg, iconMap };

package/internal/src/utils/imageDownloader.js

@@ -0,0 +1,88 @@
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+
+
+// AI GENERATED - Partially
+
+/**
+ * Downloads or copies an image from a URL or local file path to a specified directory
+ * 
+ * @param {string} source - The URL or local file path of the image
+ * @param {string} outputDir - The directory where the image should be saved
+ * @param {string} [filename='temp_image.png'] - The filename to use for the saved image
+ * @returns {Promise<string>} - A promise that resolves with the path to the saved image
+ */
+async function downloadImage(source, outputDir, filename = 'temp_image.png') {
+
+  const tmpImagePath = path.resolve(outputDir, filename);
+  
+  // Check if the source is a local file path or a URL
+  const isUrl = source.startsWith('http://') || source.startsWith('https://');
+  
+  if (isUrl) {
+    console.log(`[INFO] Downloading remote image from: ${source}`);
+    
+    return new Promise((resolve, reject) => {
+      const file = fs.createWriteStream(tmpImagePath);
+      
+      https.get(source, (response) => {
+        if (response.statusCode !== 200) {
+          reject(new Error(`Failed to download image, status code: ${response.statusCode}`));
+          return;
+        }
+        
+        response.pipe(file);
+        
+        file.on('finish', () => {
+          file.close();
+          resolve(tmpImagePath);
+        });
+        
+        file.on('error', (err) => {
+          fs.unlink(tmpImagePath, () => {});
+          reject(err);
+        });
+      }).on('error', (err) => {
+        fs.unlink(tmpImagePath, () => {});
+        reject(err);
+      });
+    });
+  } else {
+
+    // local file path
+    console.log(`[INFO] Copying local image from: ${source}`);
+    
+    return new Promise((resolve, reject) => {
+
+      // Check if source file exists
+      if (!fs.existsSync(source)) {
+        reject(new Error(`Source file does not exist: ${source}`));
+        return;
+      }
+      
+      // Create a read stream from the source file
+      const readStream = fs.createReadStream(source);
+      const writeStream = fs.createWriteStream(tmpImagePath);
+      
+      // Pipe the read stream to the write stream
+      readStream.pipe(writeStream);
+      
+      writeStream.on('finish', () => {
+        resolve(tmpImagePath);
+      });
+      
+      writeStream.on('error', (err) => {
+        fs.unlink(tmpImagePath, () => {});
+        reject(err);
+      });
+      
+      readStream.on('error', (err) => {
+        fs.unlink(tmpImagePath, () => {});
+        reject(err);
+      });
+    });
+  }
+}
+
+module.exports = { downloadImage };