@lee-jisoo/n8n-nodes-mediafx 1.6.25 → 1.6.27

package/README.md

@@ -10,12 +10,32 @@ This is a custom n8n node for comprehensive, local media processing using FFmpeg
 
 ## 🆕 What's New in This Fork
 
-### v1.6.25
+### v1.6.27
+**Improvements**
+
+- **🔧 FFmpeg Bundling Fix**: Now uses `ffmpeg-static` (FFmpeg 5.x) as primary source
+  - More reliable cross-platform support
+  - Fixes issues with old system FFmpeg being used instead of bundled version
+  - All advanced features (text_align, line_spacing) now work properly
+
+### v1.6.26
 **New Features**
 
-- **📝 Multi-line Text Alignment**: Added text alignment option for Add Text to Image
-  - Left, Center, Right alignment for multi-line text
-  - Useful when text contains line breaks (`\n`)
+- **📐 Auto Font Size**: Automatically calculate font size based on image dimensions
+  - `Auto - Small`: Fits text at 50% of calculated size
+  - `Auto - Medium`: Fits text at 75% of calculated size
+  - `Auto - Large`: Fits text at 100% (fills available width)
+  - Supports Korean/CJK characters with proper width weighting
+
+- **😀 Emoji Auto-Removal**: Automatically removes emojis from text
+  - Prevents broken/garbled characters in rendered output
+  - Emojis are stripped before rendering
+
+- **↕️ Line Spacing**: Adjustable spacing between lines
+  - Default 10px, configurable for multi-line text
+
+- **📝 Multi-line Text Alignment**: Text alignment for multi-line text
+  - Left, Center, Right alignment options
 
 ### v1.6.24
 **Bug Fixes**

package/dist/nodes/MediaFX/MediaFX.node.js

@@ -414,11 +414,15 @@ class MediaFX {
                             const { paths, cleanup: c } = await (0, utils_1.resolveInputs)(this, i, [sourceParam.source]);
                             cleanup = c;
                             const text = this.getNodeParameter('imageText', i, 'Hello, n8n!');
+                            const sizeMode = this.getNodeParameter('imageTextSizeMode', i, 'fixed');
                             const textOptions = {
                                 fontKey: this.getNodeParameter('imageTextFontKey', i, 'noto-sans-kr'),
-                                size: this.getNodeParameter('imageTextSize', i, 48),
+                                size: sizeMode === 'fixed'
+                                    ? this.getNodeParameter('imageTextSize', i, 48)
+                                    : sizeMode,
                                 color: this.getNodeParameter('imageTextColor', i, 'white'),
                                 textAlign: this.getNodeParameter('imageTextAlign', i, 'left'),
+                                lineSpacing: this.getNodeParameter('imageTextLineSpacing', i, 10),
                                 outlineWidth: this.getNodeParameter('imageTextOutlineWidth', i, 0),
                                 outlineColor: this.getNodeParameter('imageTextOutlineColor', i, 'black'),
                                 enableBackground: this.getNodeParameter('imageTextEnableBackground', i, false),

package/dist/nodes/MediaFX/operations/addTextToImage.js

@@ -52,6 +52,99 @@ function detectImageFormat(filePath) {
         });
     });
 }
+// Get image dimensions using ffprobe
+function getImageDimensions(filePath) {
+    return new Promise((resolve, reject) => {
+        ffmpeg.ffprobe(filePath, (err, metadata) => {
+            if (err) {
+                return reject(new Error(`Failed to probe image: ${err.message}`));
+            }
+            const videoStream = metadata.streams.find(s => s.codec_type === 'video');
+            if (!videoStream || !videoStream.width || !videoStream.height) {
+                return reject(new Error('Could not determine image dimensions'));
+            }
+            resolve({ width: videoStream.width, height: videoStream.height });
+        });
+    });
+}
+// Calculate effective text length considering character widths
+// Korean/CJK characters are roughly 2x width of Latin characters
+function calculateEffectiveTextLength(text) {
+    let length = 0;
+    for (const char of text) {
+        const code = char.charCodeAt(0);
+        // CJK characters (Korean, Chinese, Japanese)
+        if ((code >= 0xAC00 && code <= 0xD7AF) || // Korean Hangul
+            (code >= 0x3130 && code <= 0x318F) || // Korean Jamo
+            (code >= 0x4E00 && code <= 0x9FFF) || // CJK Unified Ideographs
+            (code >= 0x3040 && code <= 0x309F) || // Hiragana
+            (code >= 0x30A0 && code <= 0x30FF) // Katakana
+        ) {
+            length += 1.8; // CJK characters are wider
+        }
+        else if (char === '\n') {
+            // Newlines don't contribute to width
+            length += 0;
+        }
+        else {
+            length += 1; // Latin and other characters
+        }
+    }
+    return length;
+}
+// Remove emojis from text (emojis cause rendering issues with most fonts)
+function removeEmojis(text) {
+    // Comprehensive emoji regex pattern covering:
+    // - Emoticons, Dingbats, Symbols
+    // - Transport, Map, Alchemical symbols
+    // - Flags, Skin tone modifiers
+    // - ZWJ sequences, Variation selectors
+    const emojiPattern = /[\u{1F600}-\u{1F64F}]|[\u{1F300}-\u{1F5FF}]|[\u{1F680}-\u{1F6FF}]|[\u{1F700}-\u{1F77F}]|[\u{1F780}-\u{1F7FF}]|[\u{1F800}-\u{1F8FF}]|[\u{1F900}-\u{1F9FF}]|[\u{1FA00}-\u{1FA6F}]|[\u{1FA70}-\u{1FAFF}]|[\u{2600}-\u{26FF}]|[\u{2700}-\u{27BF}]|[\u{2300}-\u{23FF}]|[\u{2B50}]|[\u{2B55}]|[\u{231A}-\u{231B}]|[\u{23E9}-\u{23F3}]|[\u{23F8}-\u{23FA}]|[\u{25AA}-\u{25AB}]|[\u{25B6}]|[\u{25C0}]|[\u{25FB}-\u{25FE}]|[\u{2614}-\u{2615}]|[\u{2648}-\u{2653}]|[\u{267F}]|[\u{2693}]|[\u{26A1}]|[\u{26AA}-\u{26AB}]|[\u{26BD}-\u{26BE}]|[\u{26C4}-\u{26C5}]|[\u{26CE}]|[\u{26D4}]|[\u{26EA}]|[\u{26F2}-\u{26F3}]|[\u{26F5}]|[\u{26FA}]|[\u{26FD}]|[\u{2702}]|[\u{2705}]|[\u{2708}-\u{270D}]|[\u{270F}]|[\u{2712}]|[\u{2714}]|[\u{2716}]|[\u{271D}]|[\u{2721}]|[\u{2728}]|[\u{2733}-\u{2734}]|[\u{2744}]|[\u{2747}]|[\u{274C}]|[\u{274E}]|[\u{2753}-\u{2755}]|[\u{2757}]|[\u{2763}-\u{2764}]|[\u{2795}-\u{2797}]|[\u{27A1}]|[\u{27B0}]|[\u{27BF}]|[\u{FE00}-\u{FE0F}]|[\u{200D}]|[\u{20E3}]|[\u{E0020}-\u{E007F}]/gu;
+    // Remove emojis and clean up any resulting double spaces (but preserve newlines)
+    return text
+        .replace(emojiPattern, '')
+        .split('\n')
+        .map(line => line.replace(/  +/g, ' ').trim())
+        .join('\n');
+}
+// Calculate auto font size based on image dimensions and text
+function calculateAutoFontSize(imageWidth, imageHeight, text, sizeOption, // 'auto-small', 'auto-medium', 'auto-large'
+paddingX = 20) {
+    // Split by newlines and find the longest line
+    const lines = text.split('\n');
+    let maxLineLength = 0;
+    for (const line of lines) {
+        const lineLength = calculateEffectiveTextLength(line);
+        if (lineLength > maxLineLength) {
+            maxLineLength = lineLength;
+        }
+    }
+    // If empty or only newlines, use a default
+    if (maxLineLength === 0) {
+        maxLineLength = 1;
+    }
+    // Available width (with padding on both sides)
+    const availableWidth = imageWidth - (paddingX * 2);
+    // Base calculation: fit text within available width
+    // Approximate: 1 character ≈ 0.6 * fontSize in width for most fonts
+    const charWidthRatio = 0.55;
+    let baseFontSize = availableWidth / (maxLineLength * charWidthRatio);
+    // Apply size multiplier
+    const sizeMultipliers = {
+        'auto-small': 0.5,
+        'auto-medium': 0.75,
+        'auto-large': 1.0,
+    };
+    const multiplier = sizeMultipliers[sizeOption] || 0.75;
+    let fontSize = Math.floor(baseFontSize * multiplier);
+    // Also consider height constraint (text shouldn't be taller than 80% of image)
+    const lineCount = lines.length;
+    const maxHeightFontSize = Math.floor((imageHeight * 0.8) / (lineCount * 1.2)); // 1.2 for line spacing
+    fontSize = Math.min(fontSize, maxHeightFontSize);
+    // Clamp to reasonable range
+    fontSize = Math.max(12, Math.min(fontSize, 500));
+    return fontSize;
+}
 function getPositionFromAlignment(horizontalAlign, verticalAlign, paddingX, paddingY) {
     let x;
     let y;
@@ -84,7 +177,7 @@ function getPositionFromAlignment(horizontalAlign, verticalAlign, paddingX, padd
     return { x, y };
 }
 async function executeAddTextToImage(imagePath, text, options, itemIndex) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d;
     // Get font (includes bundled, user, and system fonts)
     const allFonts = (0, utils_1.getAvailableFonts)(true);
     const fontKey = options.fontKey || 'noto-sans-kr';
@@ -93,17 +186,33 @@ async function executeAddTextToImage(imagePath, text, options, itemIndex) {
         throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Selected font '${fontKey}' is not valid or its file path is missing.`, { itemIndex });
     }
     const fontPath = font.path;
-    // Set default values for text options
-    const fontSize = options.size || 48;
+    // Remove emojis from text (they cause rendering issues with most fonts)
+    const cleanedText = removeEmojis(text);
+    // Get padding values early (needed for auto font size calculation)
+    const paddingX = (_a = options.paddingX) !== null && _a !== void 0 ? _a : 20;
+    const paddingY = (_b = options.paddingY) !== null && _b !== void 0 ? _b : 20;
+    // Handle font size - support auto sizing options
+    let fontSize;
+    const sizeOption = options.size;
+    const autoSizeOptions = ['auto-small', 'auto-medium', 'auto-large'];
+    if (typeof sizeOption === 'string' && autoSizeOptions.includes(sizeOption)) {
+        // Auto font size - need to get image dimensions first
+        const dimensions = await getImageDimensions(imagePath);
+        fontSize = calculateAutoFontSize(dimensions.width, dimensions.height, cleanedText, sizeOption, paddingX);
+    }
+    else {
+        fontSize = sizeOption || 48;
+    }
     const fontColor = options.color || 'white';
     const textAlign = options.textAlign || 'left';
+    const lineSpacing = (_c = options.lineSpacing) !== null && _c !== void 0 ? _c : 10;
     // Outline options
     const outlineWidth = options.outlineWidth || 0;
     const outlineColor = options.outlineColor || 'black';
     // Background box options
     const enableBackground = options.enableBackground || false;
     const backgroundColor = options.backgroundColor || 'black';
-    const backgroundOpacity = (_a = options.backgroundOpacity) !== null && _a !== void 0 ? _a : 0.5;
+    const backgroundOpacity = (_d = options.backgroundOpacity) !== null && _d !== void 0 ? _d : 0.5;
     const boxPadding = options.boxPadding || 5;
     // Handle position based on position type
     let positionX;
@@ -112,8 +221,6 @@ async function executeAddTextToImage(imagePath, text, options, itemIndex) {
     if (positionType === 'alignment') {
         const horizontalAlign = options.horizontalAlign || 'center';
         const verticalAlign = options.verticalAlign || 'middle';
-        const paddingX = (_b = options.paddingX) !== null && _b !== void 0 ? _b : 20;
-        const paddingY = (_c = options.paddingY) !== null && _c !== void 0 ? _c : 20;
         const position = getPositionFromAlignment(horizontalAlign, verticalAlign, paddingX, paddingY);
         positionX = position.x;
         positionY = position.y;
@@ -138,12 +245,12 @@ async function executeAddTextToImage(imagePath, text, options, itemIndex) {
     }
     const outputPath = (0, utils_1.getTempFile)(outputExt);
     // Escape single quotes in text
-    const escapedText = text.replace(/'/g, `''`);
+    const escapedText = cleanedText.replace(/'/g, `''`);
     // Map text alignment to FFmpeg format (L=left, C=center, R=right)
     const textAlignMap = { left: 'L', center: 'C', right: 'R' };
     const ffmpegTextAlign = textAlignMap[textAlign] || 'L';
     // Build drawtext filter
-    let drawtext = `drawtext=fontfile=${fontPath}:text='${escapedText}':fontsize=${fontSize}:fontcolor=${fontColor}:x=${positionX}:y=${positionY}:text_align=${ffmpegTextAlign}`;
+    let drawtext = `drawtext=fontfile=${fontPath}:text='${escapedText}':fontsize=${fontSize}:fontcolor=${fontColor}:x=${positionX}:y=${positionY}:text_align=${ffmpegTextAlign}:line_spacing=${lineSpacing}`;
     // Add outline (border) if width > 0
     if (outlineWidth > 0) {
         drawtext += `:borderw=${outlineWidth}:bordercolor=${outlineColor}`;

package/dist/nodes/MediaFX/properties/image.properties.js

@@ -93,6 +93,25 @@ exports.imageProperties = [
         },
         description: 'Select a font for the text',
     },
+    {
+        displayName: 'Font Size Mode',
+        name: 'imageTextSizeMode',
+        type: 'options',
+        options: [
+            { name: 'Fixed (px)', value: 'fixed' },
+            { name: 'Auto - Small', value: 'auto-small', description: 'Automatically fit text, smaller size' },
+            { name: 'Auto - Medium', value: 'auto-medium', description: 'Automatically fit text, medium size' },
+            { name: 'Auto - Large', value: 'auto-large', description: 'Automatically fit text, fills available width' },
+        ],
+        default: 'fixed',
+        displayOptions: {
+            show: {
+                resource: ['image'],
+                operation: ['addTextToImage'],
+            },
+        },
+        description: 'How to determine font size. Auto modes calculate size based on image dimensions and text length.',
+    },
     {
         displayName: 'Font Size',
         name: 'imageTextSize',
@@ -105,6 +124,7 @@ exports.imageProperties = [
             show: {
                 resource: ['image'],
                 operation: ['addTextToImage'],
+                imageTextSizeMode: ['fixed'],
             },
         },
         description: 'Font size in pixels',
@@ -140,6 +160,22 @@ exports.imageProperties = [
         },
         description: 'Text alignment for multi-line text (when text contains line breaks)',
     },
+    {
+        displayName: 'Line Spacing',
+        name: 'imageTextLineSpacing',
+        type: 'number',
+        default: 10,
+        typeOptions: {
+            minValue: 0,
+        },
+        displayOptions: {
+            show: {
+                resource: ['image'],
+                operation: ['addTextToImage'],
+            },
+        },
+        description: 'Additional spacing between lines in pixels (for multi-line text)',
+    },
     {
         displayName: 'Outline Width',
         name: 'imageTextOutlineWidth',

package/dist/nodes/MediaFX/utils.js

@@ -40,48 +40,74 @@ let ffmpegInitialized = false;
 function tryInitializeFfmpeg() {
     if (ffmpegInitialized)
         return true;
+    let ffmpegBinaryPath = null;
+    let ffprobeBinaryPath = null;
+    // Strategy 1: Try ffmpeg-static (recommended, includes FFmpeg 5.x+)
     try {
         // eslint-disable-next-line @typescript-eslint/no-require-imports
-        const ffmpegInstaller = require('@ffmpeg-installer/ffmpeg');
+        const ffmpegStatic = require('ffmpeg-static');
+        if (ffmpegStatic && fs.existsSync(ffmpegStatic)) {
+            ffmpegBinaryPath = ffmpegStatic;
+            console.log(`FFmpeg found via ffmpeg-static: ${ffmpegStatic}`);
+        }
+    }
+    catch (e) {
+        console.warn('ffmpeg-static not available, trying fallback...');
+    }
+    // Strategy 2: Fallback to @ffmpeg-installer/ffmpeg
+    if (!ffmpegBinaryPath) {
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const ffmpegInstaller = require('@ffmpeg-installer/ffmpeg');
+            if (ffmpegInstaller.path && fs.existsSync(ffmpegInstaller.path)) {
+                ffmpegBinaryPath = ffmpegInstaller.path;
+                console.log(`FFmpeg found via @ffmpeg-installer: ${ffmpegInstaller.path}`);
+            }
+        }
+        catch (e) {
+            console.warn('@ffmpeg-installer/ffmpeg not available');
+        }
+    }
+    // Get ffprobe from @ffprobe-installer/ffprobe
+    try {
         // eslint-disable-next-line @typescript-eslint/no-require-imports
         const ffprobeInstaller = require('@ffprobe-installer/ffprobe');
-        const ffmpegInstallerPath = ffmpegInstaller.path;
-        const ffprobeInstallerPath = ffprobeInstaller.path;
-        if (ffmpegInstallerPath && fs.existsSync(ffmpegInstallerPath) && ffprobeInstallerPath && fs.existsSync(ffprobeInstallerPath)) {
-            // Set executable permissions dynamically
-            if (os.platform() !== 'win32') {
-                try {
-                    fs.chmodSync(ffmpegInstallerPath, '755');
-                    fs.chmodSync(ffprobeInstallerPath, '755');
-                    console.log('Dynamically set permissions for ffmpeg and ffprobe.');
-                }
-                catch (permissionError) {
-                    console.warn('Failed to set executable permissions dynamically:', permissionError);
-                }
-            }
-            ffmpeg.setFfmpegPath(ffmpegInstallerPath);
-            ffmpeg.setFfprobePath(ffprobeInstallerPath);
-            ffmpegPath = ffmpegInstallerPath;
-            ffmpegInitialized = true;
-            console.log(`FFmpeg initialized with @ffmpeg-installer: ${ffmpegInstallerPath}`);
-            console.log(`FFprobe initialized with @ffprobe-installer: ${ffprobeInstallerPath}`);
-            return true;
+        if (ffprobeInstaller.path && fs.existsSync(ffprobeInstaller.path)) {
+            ffprobeBinaryPath = ffprobeInstaller.path;
+            console.log(`FFprobe found via @ffprobe-installer: ${ffprobeInstaller.path}`);
         }
     }
-    catch (error) {
-        // This is the only strategy, so if it fails, we throw.
-        console.error('Failed to load FFmpeg/FFprobe from node_modules.', error);
-        throw new n8n_workflow_1.NodeOperationError(
-        // We can't use `this.getNode()` here as we are in a utility function.
-        // A generic error is sufficient.
-        { name: 'MediaFX', type: 'n8n-nodes-mediafx.mediaFX' }, 'Could not load the required FFmpeg executable from the package. ' +
-            'This might be due to a restricted execution environment or a broken installation. ' +
-            'Please check your n8n environment permissions. ' +
-            `Original error: ${error.message}`);
+    catch (e) {
+        console.warn('@ffprobe-installer/ffprobe not available');
+    }
+    // Validate and set paths
+    if (!ffmpegBinaryPath) {
+        console.error('FFmpeg binary not found in any package.');
+        throw new n8n_workflow_1.NodeOperationError({ name: 'MediaFX', type: 'n8n-nodes-mediafx.mediaFX' }, 'Could not find FFmpeg executable. Please ensure ffmpeg-static or @ffmpeg-installer/ffmpeg is properly installed.');
+    }
+    if (!ffprobeBinaryPath) {
+        console.error('FFprobe binary not found.');
+        throw new n8n_workflow_1.NodeOperationError({ name: 'MediaFX', type: 'n8n-nodes-mediafx.mediaFX' }, 'Could not find FFprobe executable. Please ensure @ffprobe-installer/ffprobe is properly installed.');
     }
-    // If we get here, something went wrong, but the catch didn't trigger.
-    console.error('FFmpeg binaries were not found in the expected package path.');
-    return false;
+    // Set executable permissions on non-Windows systems
+    if (os.platform() !== 'win32') {
+        try {
+            fs.chmodSync(ffmpegBinaryPath, '755');
+            fs.chmodSync(ffprobeBinaryPath, '755');
+            console.log('Set executable permissions for ffmpeg and ffprobe.');
+        }
+        catch (permissionError) {
+            console.warn('Failed to set executable permissions:', permissionError);
+        }
+    }
+    // Configure fluent-ffmpeg
+    ffmpeg.setFfmpegPath(ffmpegBinaryPath);
+    ffmpeg.setFfprobePath(ffprobeBinaryPath);
+    ffmpegPath = ffmpegBinaryPath;
+    ffmpegInitialized = true;
+    console.log(`FFmpeg initialized: ${ffmpegBinaryPath}`);
+    console.log(`FFprobe initialized: ${ffprobeBinaryPath}`);
+    return true;
 }
 // Try to initialize FFmpeg on module load
 tryInitializeFfmpeg();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lee-jisoo/n8n-nodes-mediafx",
-  "version": "1.6.25",
+  "version": "1.6.27",
   "description": "N8N custom nodes for video editing and media processing (Enhanced fork with Speed control and Subtitle fixes)",
   "license": "MIT",
   "author": {