[ImageMagick] Render Every GIF Frame with -coalesce

// Save this file with the .mjs extension so that it runs as an ES module.
// Alternatively, add "type": "module" to package.json.

import fs from 'fs/promises';
import path from 'path';
import sharp from 'sharp';

/**
 * Processes GIF and PNG images inside the specified directory.
 *
 * - Images that already have a 1:1 aspect ratio and are no larger than
 *   128px by 128px are copied directly to the output folder.
 * - All other images are resized to a 1:1 aspect ratio of 128px by 128px.
 * - During resizing, the image is aligned to the bottom, with transparent
 *   padding added above it and, where necessary, to the left and right.
 * - GIF animation is preserved.
 *
 * @param {string} inputDir - Path to the input directory to process.
 */
async function processImages(inputDir) {
  // The output directory is created as a subfolder of the input directory.
  const outputDir = path.join(inputDir, 'output_resized');
  const targetSize = 128; // Target size after resizing, such as 128px by 128px.

  try {
    // Check whether the input directory exists.
    const stats = await fs.stat(inputDir);
    if (!stats.isDirectory()) {
      console.error(`Error: The specified path "${inputDir}" is not a directory.`);
      return;
    }

    // Create the output directory if it does not exist.
    await fs.mkdir(outputDir, { recursive: true });
    console.log(`Created output directory: "${outputDir}".`);

    // Read every file inside the input directory.
    const files = await fs.readdir(inputDir);
    console.log(`Found ${files.length} files in "${inputDir}".`);

    // Process each file in parallel.
    await Promise.all(files.map(async (file) => {
      const filePath = path.join(inputDir, file);
      const ext = path.extname(file).toLowerCase();
      const fileNameWithoutExt = path.basename(file, ext);
      const outputPath = path.join(outputDir, `${fileNameWithoutExt}${ext}`);

      try {
        const fileStats = await fs.stat(filePath);

        // Skip directories and files that have already been resized.
        if (fileStats.isDirectory() || file.endsWith('_resized' + ext)) {
          console.log(`Skipped "${file}" because it is a directory or an existing resized file.`);
          return;
        }
      } catch (statError) {
        console.warn(`Could not inspect "${file}". Skipping it. Error: ${statError.message}`);
        return;
      }

      // Check whether the file is a GIF or PNG.
      if (ext !== '.gif' && ext !== '.png') {
        console.log(`Skipped "${file}" because its format is not supported.`);
        return;
      }

      try {
        console.log(`Processing "${file}"...`);

        let imageProcessor;

        // For GIF images, load them with the animated option enabled.
        if (ext === '.gif') {
          imageProcessor = sharp(filePath, { animated: true });
        } else {
          imageProcessor = sharp(filePath);
        }

        // Read image metadata such as width and height.
        const metadata = await imageProcessor.metadata();
        const { width, height } = metadata;

        // Skip the file if its metadata cannot be read.
        if (!width || !height) {
          console.warn(`Could not read metadata from "${file}". Skipping it.`);
          return;
        }

        const maxOriginalDim = Math.max(width, height);

        // If the image already has a 1:1 aspect ratio and its longest side
        // is no larger than targetSize, copy it without resizing or padding.
        if (width === height && maxOriginalDim <= targetSize) {
          await fs.copyFile(filePath, outputPath);
          console.log(
            `"${file}" already has a 1:1 aspect ratio and is no larger than ` +
            `${targetSize}px, so it was copied directly to "${outputPath}".`
          );
          return;
        }

        // Resize every other image:
        // - A 1:1 image larger than targetSize, such as 200x200, is reduced to 128x128.
        // - A non-square image, such as 200x100 or 50x100, is fitted into a
        //   transparent 128x128 canvas while preserving its aspect ratio.
        imageProcessor = imageProcessor.resize(targetSize, targetSize, {
          fit: sharp.fit.contain,
          position: sharp.strategy.south,
          background: { r: 0, g: 0, b: 0, alpha: 0 }
        });

        // Save the resized image.
        // For GIF images, preserve the animation.
        if (ext === '.gif') {
          await imageProcessor.gif({ animated: true }).toFile(outputPath);
        } else {
          await imageProcessor.toFile(outputPath);
        }

        console.log(`Successfully resized "${file}" to "${outputPath}".`);
      } catch (error) {
        console.error(`An error occurred while processing "${file}":`, error);
      }
    }));

    console.log("Finished processing all images.");
  } catch (error) {
    console.error("An error occurred while running the script:", error);
  }
}

// Read the input directory from the command-line arguments.
// process.argv[0] is "node", and process.argv[1] is the script filename.
const args = process.argv.slice(2);
const inputDirectory = args[0] || './';

// Run the script.
processImages(inputDirectory);