@igxjs/text2png 3.0.2 → 3.0.4

package/LICENSE

@@ -1,6 +1,7 @@
 MIT License
 
-Copyright (c) 2018
+Copyright (c) 2018 Taka Kojima (original author)
+Copyright (c) 2026 Michael (igxjs) (modifications and maintenance)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,89 +1,217 @@
-# Text to PNG
+# text2png
 
-We upgraded the `node-canvas` to latest in order to support Node.js v24+.
+Convert text to PNG images with optional fixed dimensions and auto-scaling.
 
-```js
-text2png('Create png image\nfrom multi-line text!');
+## Installation
+
+```bash
+npm install @igxjs/text2png
 ```
 
-![text2png](./img/text2png.png)
+**Requirements:** [node-canvas](https://github.com/Automattic/node-canvas) (see [installation guide](https://github.com/Automattic/node-canvas/wiki))
 
-## Quick start
+## Quick Start
 
-text2png depends on [node-canvas](https://github.com/Automattic/node-canvas).
-See [node-canvas wiki](https://github.com/Automattic/node-canvas/wiki) on installing node-canvas.
+```js
+const fs = require('fs');
+const text2png = require('@igxjs/text2png');
 
-```
-$ npm install @igxjs/text2png
+// Basic usage
+fs.writeFileSync('output.png', text2png('Hello World!'));
+
+// With styling
+fs.writeFileSync('styled.png', text2png('Hello!', {
+  font: '40px Arial',
+  color: 'blue',
+  backgroundColor: 'white',
+  padding: 20
+}));
+
+// Fixed size (great for avatars!)
+fs.writeFileSync('avatar.png', text2png('IGX', {
+  width: 200,
+  height: 200,
+  font: '80px Arial',
+  textColor: 'white',
+  backgroundColor: '#4F46E5',
+  textAlign: 'center',
+  verticalAlign: 'middle'
+}));
 ```
 
+## API
+
+### `text2png(text, options)`
+
+#### Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| **Text Styling** |
+| `font` | string | `'30px sans-serif'` | CSS font string |
+| `color` / `textColor` | string | `'black'` | Text color (any CSS color) |
+| `textAlign` | string | `'left'` | Horizontal alignment: `'left'`, `'center'`, `'right'` |
+| `strokeWidth` | number | `0` | Text stroke/outline width |
+| `strokeColor` | string | `'white'` | Text stroke color |
+| **Background & Spacing** |
+| `backgroundColor` / `bgColor` | string | `transparent` | Background color |
+| `padding` | number | `0` | Padding on all sides |
+| `paddingLeft/Right/Top/Bottom` | number | `0` | Individual side padding |
+| `lineSpacing` | number | `0` | Extra spacing between lines |
+| **Border** |
+| `borderWidth` | number | `0` | Border width on all sides |
+| `borderLeft/Right/Top/BottomWidth` | number | `0` | Individual border widths |
+| `borderColor` | string | `'black'` | Border color |
+| **Fixed Dimensions** ⭐ |
+| `width` | number | `null` | Fixed width (auto-scales content to fit) |
+| `height` | number | `null` | Fixed height (auto-scales content to fit) |
+| `minFontSize` | number | `8` | Minimum font size when auto-scaling |
+| `verticalAlign` | string | `'middle'` | Vertical alignment: `'top'`, `'middle'`, `'bottom'` |
+| **Font Loading** |
+| `localFontPath` | string | `null` | Path to custom font file |
+| `localFontName` | string | `null` | Name to register custom font as |
+| **Output** |
+| `output` | string | `'buffer'` | Output format: `'buffer'`, `'stream'`, `'dataURL'`, `'canvas'` |
+| `imageSmoothingEnabled` | boolean | `false` | Enable image smoothing |
+
+## Examples
+
+### Auto-sized Image (Default)
 ```js
-const fs = require('fs');
-const text2png = require('text2png');
-fs.writeFileSync('out.png', text2png('Hello!', { color: 'blue' }));
+const image = text2png('Hello\nWorld', {
+  font: '30px Arial',
+  color: 'teal',
+  backgroundColor: 'linen',
+  padding: 20
+});
+// Image size automatically fits the text
 ```
 
-## Option
+![Auto-sized Example](./samples/test-auto-size.png)
+
+### Fixed Size with Auto-scaling
+```js
+// Long text automatically scales down to fit
+const banner = text2png('This is a very long text that needs to fit!', {
+  width: 300,
+  height: 100,
+  font: '40px Arial',
+  textAlign: 'center',
+  verticalAlign: 'middle',
+  backgroundColor: '#f0f0f0'
+});
+// Text font size automatically scales to fit 300x100
+```
 
-``text2png(text, option)``
+![Auto-scaled Text Example](./samples/test-scaled.png)
 
-|param|default|
-|---|---|
-|text|(required)|
-|option.font|'30px sans-serif'|
-|option.textAlign|'left'|
-|option.color (or option.textColor)|'black'|
-|option.backgroundColor (or option.bgColor)|'transparent'|
-|option.lineSpacing|0|
-|option.strokeWidth|0|
-|option.strokeColor|'white'|
-|option.padding|0|
-|option.padding(Left\|Top\|Right\|Bottom)|0|
-|option.borderWidth|0|
-|option.border(Left\|Top\|Right\|Bottom)Width|0|
-|option.borderColor|'black'|
-|option.localFontPath||
-|option.localFontName||
-|option.output|'buffer'|
+### User Avatar
+```js
+const avatar = text2png('IGX', {
+  width: 200,
+  height: 200,
+  font: '80px Arial',
+  textColor: 'white',
+  backgroundColor: '#4F46E5',
+  textAlign: 'center',
+  verticalAlign: 'middle'
+});
+```
 
-``option.color = '#000' | 'rgb(0, 0, 0)' | 'black' | ...``
+![Avatar Example](./samples/test-avatar.png)
 
-``option.output = 'buffer' | 'stream' | 'dataURL' | 'canvas'``
+### Multi-line with Fixed Dimensions
+```js
+const multiLine = text2png('Line 1\nLine 2\nLine 3', {
+  width: 250,
+  height: 150,
+  font: '24px Arial',
+  textColor: '#333',
+  backgroundColor: '#fff',
+  textAlign: 'center',
+  verticalAlign: 'middle',
+  padding: 10,
+  borderWidth: 1,
+  borderColor: '#ccc',
+  lineSpacing: 8  // Add spacing between lines
+});
+```
 
-``option.strokeWidth = 1 | 2 | ... `` A padding may have to be set to avoid cutoff of stroke
+![Multi-line Example](./samples/test-multiline.png)
 
-``'canvas'`` returns [node-canvas](https://github.com/Automattic/node-canvas) object.
+### Fixed Width, Auto Height
+```js
+const card = text2png('Hello World', {
+  width: 400,  // Fixed width
+  // Height auto-calculates to 65px
+  font: '30px Arial',
+  textColor: 'blue',
+  backgroundColor: 'white',
+  textAlign: 'center',
+  padding: 20,
+  borderWidth: 2,
+  borderColor: 'blue'
+});
+```
 
-If you want to use any custom fonts without installing, use `localFontPath` and `localFontName` property.
+![Fixed Width Example](./samples/test-fixed-width.png)
 
+### Custom Font
 ```js
-text2png('with custom fonts', {
+const styled = text2png('Fancy Text', {
   font: '50px Lobster',
-  localFontPath: 'fonts/Lobstar-Regular.ttf',
+  localFontPath: './fonts/Lobster-Regular.ttf',
   localFontName: 'Lobster'
 });
 ```
 
-## Command line interface
+## How Fixed Dimensions Work
 
-```
-$ npm install -g text2png
-$ text2png --help
-$ text2png -t "Hello!" -o "output.png"
+When you specify `width` and/or `height`:
+
+1. ✅ **Fits naturally** → Content is centered based on alignment options
+2. 📏 **Too large** → Font automatically scales down to fit (respects `minFontSize`)
+3. ✂️ **Exceeds minimum** → Content is clipped at boundaries
+
+Without `width`/`height`, the image auto-sizes to fit content (original behavior).
+
+## CLI Usage
+
+```bash
+npm install -g @igxjs/text2png
+text2png --help
+text2png -t "Hello!" -o output.png
+
+# Create an avatar
+text2png -t "IGX" -o avatar.png --width 200 --height 200 \
+  --font "80px Arial" --color white --backgroundColor "#4F46E5" \
+  --textAlign center --verticalAlign middle
 ```
 
-## Example
+## Output Formats
 
 ```js
-text2png('Example\nText', {
-  font: '80px Futura',
-  color: 'teal',
-  backgroundColor: 'linen',
-  lineSpacing: 10,
-  padding: 20
-});
+// Buffer (default) - for file writing
+const buffer = text2png('text', { output: 'buffer' });
+fs.writeFileSync('out.png', buffer);
+
+// Stream - for piping
+const stream = text2png('text', { output: 'stream' });
+stream.pipe(fs.createWriteStream('out.png'));
+
+// Data URL - for HTML/CSS
+const dataURL = text2png('text', { output: 'dataURL' });
+// image/png;base64,...
+
+// Canvas - for further manipulation
+const canvas = text2png('text', { output: 'canvas' });
+const ctx = canvas.getContext('2d');
 ```
 
-![ExampleText](./img/exampleText.png)
+## License
+
+MIT
+
+## Credits
 
-Enjoy!
+Built on [node-canvas](https://github.com/Automattic/node-canvas). Updated for Node.js v24+ compatibility.

package/bin/text2png.js

@@ -1,10 +1,12 @@
 #!/usr/bin/env node
 
-const fs = require("fs");
-const path = require("path");
+const fs = require("node:fs");
+const path = require("node:path");
+
 const commander = require("commander");
-const version = require("../package.json").version;
-const text2png = require("../index.js");
+
+const { version } = require("../package.json");
+const text2png = require('../index.js');
 
 commander
   .version(version)
@@ -18,7 +20,12 @@ commander
   .option("-s, --lineSpacing <number>", "line spacing")
 
   .option("--strokeWidth <number>", "stroke width")
-  .option("--strokeColor <number>", "stroke color")
+  .option("--strokeColor <color>", "stroke color")
+
+  .option("--width <number>", "fixed width in pixels")
+  .option("--height <number>", "fixed height in pixels")
+  .option("--minFontSize <number>", "minimum font size when auto-scaling (default: 8)")
+  .option("--verticalAlign <alignment>", "vertical alignment: top, middle, bottom (default: middle)")
 
   .option(
     "-p, --padding <number>",
@@ -47,40 +54,57 @@ commander
 
   .parse(process.argv);
 
+// Helper function to convert string to number
+const toNumber = value => value ? +value : undefined;
+
+// Helper function to build options object from commander
+const buildOptions = (commander) => ({
+  font: commander.font,
+  textAlign: commander.textAlign,
+  color: commander.color,
+  backgroundColor: commander.backgroundColor,
+  lineSpacing: toNumber(commander.lineSpacing),
+
+  strokeWidth: toNumber(commander.strokeWidth),
+  strokeColor: commander.strokeColor,
+
+  padding: toNumber(commander.padding),
+  paddingLeft: toNumber(commander.paddingLeft),
+  paddingTop: toNumber(commander.paddingTop),
+  paddingRight: toNumber(commander.paddingRight),
+  paddingBottom: toNumber(commander.paddingBottom),
+
+  borderWidth: toNumber(commander.borderWidth),
+  borderLeftWidth: toNumber(commander.borderLeftWidth),
+  borderTopWidth: toNumber(commander.borderTopWidth),
+  borderRightWidth: toNumber(commander.borderRightWidth),
+  borderBottomWidth: toNumber(commander.borderBottomWidth),
+  borderColor: commander.borderColor,
+
+  localFontPath: commander.localFontPath,
+  localFontName: commander.localFontName,
+
+  width: toNumber(commander.width),
+  height: toNumber(commander.height),
+  minFontSize: toNumber(commander.minFontSize),
+  verticalAlign: commander.verticalAlign,
+
+  output: "stream",
+  imageSmoothingEnabled: false
+});
+
 const exec = text => {
-  if ((commander.text || text) && commander.output) {
-    const stream = text2png(commander.text || text, {
-      font: commander.font,
-      textAlign: commander.textAlign,
-      color: commander.color,
-      backgroundColor: commander.backgroundColor,
-      lineSpacing: commander.lineSpacing && +commander.lineSpacing,
-
-      padding: commander.padding && +commander.padding,
-      paddingLeft: commander.paddingLeft && +commander.paddingLeft,
-      paddingTop: commander.paddingTop && +commander.paddingTop,
-      paddingRight: commander.paddingRight && +commander.paddingRight,
-      paddingBottom: commander.paddingBottom && +commander.paddingBottom,
-
-      borderWidth: commander.borderWidth && +commander.borderWidth,
-      borderLeftWidth: commander.borderLeftWidth && +commander.borderLeftWidth,
-      borderTopWidth: commander.borderTopWidth && +commander.borderTopWidth,
-      borderRightWidth:
-        commander.borderRightWidth && +commander.borderRightWidth,
-      borderBottomWidth:
-        commander.borderBottomWidth && +commander.borderBottomWidth,
-      borderColor: commander.borderColor,
-
-      localFontPath: commander.localFontPath,
-      localFontName: commander.localFontName,
-
-      output: "stream"
-    });
-    const outputPath = path.resolve(process.cwd(), commander.output);
-    stream.pipe(fs.createWriteStream(outputPath));
-  } else {
+  const textInput = commander.text || text;
+  
+  if (!textInput || !commander.output) {
     commander.outputHelp();
+    return;
   }
+
+  const options = buildOptions(commander);
+  const stream = text2png(textInput, options);
+  const outputPath = path.resolve(process.cwd(), commander.output);
+  stream.pipe(fs.createWriteStream(outputPath));
 };
 
 if (process.stdin.isTTY) {

package/index.js

@@ -7,30 +7,54 @@ const { registerFont, createCanvas } = require("canvas");
  * @returns {string|Buffer|import('node:stream').Readable|import('canvas').Canvas} Returns PNG data as specified by options.output
  */
 const text2png = (text, options = {}) => {
-  // Options
   options = parseOptions(options);
+  registerCustomFont(options);
 
-  // Register a custom font
+  const canvas = createCanvas(0, 0);
+  const ctx = canvas.getContext("2d");
+
+  // Measure text and calculate natural dimensions
+  const textMetrics = measureTextMetrics(ctx, text, options);
+  const naturalDimensions = calculateNaturalDimensions(textMetrics, options);
+
+  // Apply dimensions and scaling
+  const dimensions = applyDimensions(canvas, textMetrics, naturalDimensions, options);
+
+  // Render background and border
+  renderBackground(ctx, canvas, options);
+
+  // Configure context for text rendering
+  configureContext(ctx, dimensions.finalFont, dimensions.scaleFactor, options);
+
+  // Calculate positioning offsets
+  const offsets = calculateOffsets(canvas, dimensions, options);
+
+  // Render text lines
+  renderTextLines(ctx, dimensions.scaledLineProps, dimensions.scaledMax, dimensions.scaledLineHeight, offsets, options, canvas);
+
+  return formatOutput(canvas, options);
+};
+
+/**
+ * Register custom font if provided
+ */
+function registerCustomFont(options) {
   if (options.localFontPath && options.localFontName) {
     try {
       registerFont(options.localFontPath, { family: options.localFontName });
-    }
-    catch(error) {
+    } catch (error) {
       throw new Error(`Failed to load local font from path: ${options.localFontPath}, error: ${error.message}`);
     }
   }
+}
 
-  const canvas = createCanvas(0, 0);
-  const ctx = canvas.getContext("2d");
-
-  const max = {
-    left: 0,
-    right: 0,
-    ascent: 0,
-    descent: 0
-  };
-
+/**
+ * Measure text and calculate metrics for all lines
+ */
+function measureTextMetrics(ctx, text, options) {
+  const max = { left: 0, right: 0, ascent: 0, descent: 0 };
   let lastDescent;
+
   const lineProps = text.split("\n").map(line => {
     ctx.font = options.font;
     const metrics = ctx.measureText(line);
@@ -50,89 +74,220 @@ const text2png = (text, options = {}) => {
   });
 
   const lineHeight = max.ascent + max.descent + options.lineSpacing;
-
   const contentWidth = max.left + max.right;
-  const contentHeight =
-    lineHeight * lineProps.length -
-    options.lineSpacing -
-    (max.descent - lastDescent);
-
-  canvas.width =
-    contentWidth +
-    options.borderLeftWidth +
-    options.borderRightWidth +
-    options.paddingLeft +
-    options.paddingRight;
-
-  canvas.height =
-    contentHeight +
-    options.borderTopWidth +
-    options.borderBottomWidth +
-    options.paddingTop +
-    options.paddingBottom;
-
-  const hasBorder =
-    options.borderLeftWidth ||
-    options.borderTopWidth ||
-    options.borderRightWidth ||
-    options.borderBottomWidth || false;
+  const contentHeight = lineHeight * lineProps.length - options.lineSpacing - (max.descent - lastDescent);
+
+  return { max, lineProps, lastDescent, lineHeight, contentWidth, contentHeight };
+}
+
+/**
+ * Calculate natural canvas dimensions without fixed sizing
+ */
+function calculateNaturalDimensions(textMetrics, options) {
+  const width = textMetrics.contentWidth +
+    options.borderLeftWidth + options.borderRightWidth +
+    options.paddingLeft + options.paddingRight;
+
+  const height = textMetrics.contentHeight +
+    options.borderTopWidth + options.borderBottomWidth +
+    options.paddingTop + options.paddingBottom;
+
+  return { width, height };
+}
+
+/**
+ * Apply dimensions and calculate scaling if needed
+ */
+function applyDimensions(canvas, textMetrics, naturalDimensions, options) {
+  const hasFixedDimensions = options.width || options.height;
+
+  if (!hasFixedDimensions) {
+    // Auto-size mode
+    canvas.width = naturalDimensions.width;
+    canvas.height = naturalDimensions.height;
+    return {
+      scaleFactor: 1,
+      finalFont: options.font,
+      scaledMax: { ...textMetrics.max },
+      scaledLineProps: textMetrics.lineProps,
+      scaledLineHeight: textMetrics.lineHeight
+    };
+  }
+
+  // Fixed dimension mode
+  const targetWidth = options.width || naturalDimensions.width;
+  const targetHeight = options.height || naturalDimensions.height;
+
+  canvas.width = targetWidth;
+  canvas.height = targetHeight;
+
+  const availableWidth = targetWidth - options.borderLeftWidth - options.borderRightWidth - options.paddingLeft - options.paddingRight;
+  const availableHeight = targetHeight - options.borderTopWidth - options.borderBottomWidth - options.paddingTop - options.paddingBottom;
+
+  let scaleFactor = calculateScaleFactor(textMetrics.contentWidth, textMetrics.contentHeight, availableWidth, availableHeight);
+
+  if (scaleFactor < 1) {
+    const scalingResult = applyFontScaling(options.font, scaleFactor, options.minFontSize);
+    scaleFactor = scalingResult.actualScaleFactor;
+
+    return {
+      scaleFactor,
+      finalFont: scalingResult.finalFont,
+      scaledMax: scaleMetrics(textMetrics.max, scaleFactor),
+      scaledLineProps: scaleLineProps(textMetrics.lineProps, scaleFactor),
+      scaledLineHeight: textMetrics.lineHeight * scaleFactor
+    };
+  }
+
+  return {
+    scaleFactor: 1,
+    finalFont: options.font,
+    scaledMax: { ...textMetrics.max },
+    scaledLineProps: textMetrics.lineProps,
+    scaledLineHeight: textMetrics.lineHeight
+  };
+}
+
+/**
+ * Apply font scaling based on scale factor and minimum font size
+ */
+function applyFontScaling(font, scaleFactor, minFontSize) {
+  const originalFontSize = extractFontSize(font);
+  const scaledFontSize = Math.max(originalFontSize * scaleFactor, minFontSize);
+  const actualScaleFactor = scaledFontSize === minFontSize ? scaledFontSize / originalFontSize : scaleFactor;
+
+  return {
+    finalFont: setFontSize(font, scaledFontSize),
+    actualScaleFactor
+  };
+}
+
+/**
+ * Scale metrics object
+ */
+function scaleMetrics(max, scaleFactor) {
+  return {
+    left: max.left * scaleFactor,
+    right: max.right * scaleFactor,
+    ascent: max.ascent * scaleFactor,
+    descent: max.descent * scaleFactor
+  };
+}
+
+/**
+ * Scale line properties
+ */
+function scaleLineProps(lineProps, scaleFactor) {
+  return lineProps.map(prop => ({
+    line: prop.line,
+    left: prop.left * scaleFactor,
+    right: prop.right * scaleFactor,
+    ascent: prop.ascent * scaleFactor,
+    descent: prop.descent * scaleFactor
+  }));
+}
+
+/**
+ * Render background and border
+ */
+function renderBackground(ctx, canvas, options) {
+  const hasBorder = options.borderLeftWidth || options.borderTopWidth || options.borderRightWidth || options.borderBottomWidth;
 
   if (hasBorder) {
     ctx.fillStyle = options.borderColor;
     ctx.fillRect(0, 0, canvas.width, canvas.height);
   }
 
+  const innerX = options.borderLeftWidth;
+  const innerY = options.borderTopWidth;
+  const innerWidth = canvas.width - (options.borderLeftWidth + options.borderRightWidth);
+  const innerHeight = canvas.height - (options.borderTopWidth + options.borderBottomWidth);
+
   if (options.backgroundColor) {
     ctx.fillStyle = options.backgroundColor;
-    ctx.fillRect(
-      options.borderLeftWidth,
-      options.borderTopWidth,
-      canvas.width - (options.borderLeftWidth + options.borderRightWidth),
-      canvas.height - (options.borderTopWidth + options.borderBottomWidth)
-    );
+    ctx.fillRect(innerX, innerY, innerWidth, innerHeight);
   } else if (hasBorder) {
-    ctx.clearRect(
-      options.borderLeftWidth,
-      options.borderTopWidth,
-      canvas.width - (options.borderLeftWidth + options.borderRightWidth),
-      canvas.height - (options.borderTopWidth + options.borderBottomWidth)
-    );
+    ctx.clearRect(innerX, innerY, innerWidth, innerHeight);
   }
+}
 
-  ctx.font = options.font;
+/**
+ * Configure canvas context for text rendering
+ */
+function configureContext(ctx, finalFont, scaleFactor, options) {
+  ctx.font = finalFont;
   ctx.fillStyle = options.textColor;
   ctx.antialias = 'gray';
   ctx.imageSmoothingEnabled = options.imageSmoothingEnabled;
   ctx.textAlign = options.textAlign;
-  ctx.lineWidth = options.strokeWidth;
+  ctx.lineWidth = options.strokeWidth * scaleFactor;
   ctx.strokeStyle = options.strokeColor;
+}
 
-  let offsetY = options.borderTopWidth + options.paddingTop;
-  lineProps.forEach(lineProp => {
-    // Calculate Y
-    let x = 0;
-    const y = max.ascent + offsetY;
-
-    // Calculate X
-    switch (options.textAlign) {
-      case "start":
-      case "left":
-        x = lineProp.left + options.borderLeftWidth + options.paddingLeft;
-        break;
-
-      case "end":
-      case "right":
-        x =
-          canvas.width -
-          lineProp.left -
-          options.borderRightWidth -
-          options.paddingRight;
-        break;
-
-      case "center":
-        x = contentWidth / 2 + options.borderLeftWidth + options.paddingLeft;
-        break;
-    }
+/**
+ * Calculate vertical and horizontal offsets for text positioning
+ */
+function calculateOffsets(canvas, dimensions, options) {
+  const verticalOffset = calculateVerticalOffset(canvas, dimensions, options);
+  const horizontalOffset = calculateHorizontalOffset(canvas, dimensions, options);
+
+  return { verticalOffset, horizontalOffset };
+}
+
+/**
+ * Calculate vertical offset based on alignment
+ */
+function calculateVerticalOffset(canvas, dimensions, options) {
+  if (!options.height) {
+    return 0;
+  }
+
+  const availableHeight = canvas.height - options.borderTopWidth - options.borderBottomWidth - options.paddingTop - options.paddingBottom;
+  const scaledContentHeight = dimensions.scaledLineHeight * dimensions.scaledLineProps.length - 
+    options.lineSpacing * dimensions.scaleFactor - 
+    (dimensions.scaledMax.descent - dimensions.scaledLineProps[dimensions.scaledLineProps.length - 1].descent);
+
+  switch (options.verticalAlign) {
+    case "top":
+      return 0;
+    case "middle":
+      return (availableHeight - scaledContentHeight) / 2;
+    case "bottom":
+      return availableHeight - scaledContentHeight;
+    default:
+      return 0;
+  }
+}
+
+/**
+ * Calculate horizontal offset based on alignment
+ */
+function calculateHorizontalOffset(canvas, dimensions, options) {
+  if (!options.width) {
+    return 0;
+  }
+
+  const availableWidth = canvas.width - options.borderLeftWidth - options.borderRightWidth - options.paddingLeft - options.paddingRight;
+  const scaledContentWidth = dimensions.scaledMax.left + dimensions.scaledMax.right;
+
+  if (options.textAlign === 'center') {
+    return (availableWidth - scaledContentWidth) / 2;
+  } else if (options.textAlign === 'right' || options.textAlign === 'end') {
+    return availableWidth - scaledContentWidth;
+  }
+
+  return 0;
+}
+
+/**
+ * Render text lines
+ */
+function renderTextLines(ctx, scaledLineProps, scaledMax, scaledLineHeight, offsets, options, canvas) {
+  let offsetY = options.borderTopWidth + options.paddingTop + offsets.verticalOffset;
+
+  scaledLineProps.forEach(lineProp => {
+    const x = calculateTextX(lineProp, scaledMax, offsets.horizontalOffset, options, canvas);
+    const y = scaledMax.ascent + offsetY;
 
     ctx.fillText(lineProp.line, x, y);
 
@@ -140,9 +295,35 @@ const text2png = (text, options = {}) => {
       ctx.strokeText(lineProp.line, x, y);
     }
 
-    offsetY += lineHeight;
+    offsetY += scaledLineHeight;
   });
+}
+
+/**
+ * Calculate X position for text based on alignment
+ */
+function calculateTextX(lineProp, scaledMax, horizontalOffset, options, canvas) {
+  switch (options.textAlign) {
+    case "start":
+    case "left":
+      return lineProp.left + options.borderLeftWidth + options.paddingLeft + horizontalOffset;
+
+    case "end":
+    case "right":
+      return canvas.width - options.borderRightWidth - options.paddingRight - horizontalOffset;
 
+    case "center":
+      return (scaledMax.left + scaledMax.right) / 2 + options.borderLeftWidth + options.paddingLeft + horizontalOffset;
+
+    default:
+      return lineProp.left + options.borderLeftWidth + options.paddingLeft + horizontalOffset;
+  }
+}
+
+/**
+ * Format output based on options
+ */
+function formatOutput(canvas, options) {
   switch (options.output) {
     case "buffer":
       return canvas.toBuffer();
@@ -155,7 +336,7 @@ const text2png = (text, options = {}) => {
     default:
       throw new Error(`output type:${options.output} is not supported.`);
   }
-};
+}
 
 function parseOptions(options) {
   return {
@@ -184,7 +365,12 @@ function parseOptions(options) {
 
     output: orOr(options.output, "buffer"),
 
-    imageSmoothingEnabled: orOr(options.imageSmoothingEnabled, false)
+    imageSmoothingEnabled: orOr(options.imageSmoothingEnabled, false),
+
+    width: orOr(options.width, null),
+    height: orOr(options.height, null),
+    minFontSize: orOr(options.minFontSize, 8),
+    verticalAlign: orOr(options.verticalAlign, "middle")
   };
 }
 
@@ -197,4 +383,42 @@ function orOr() {
   return arguments[arguments.length - 1];
 }
 
+/**
+ * Extract font size from font string (e.g., "30px sans-serif" -> 30)
+ * @param {string} font Font string
+ * @returns {number} Font size in pixels
+ */
+function extractFontSize(font) {
+  const regex = /(\d+(?:\.\d+)?)\s*px/i;
+  const match = regex.exec(font);
+  return match ? Number.parseFloat(match[1]) : 30;
+}
+
+/**
+ * Create new font string with different size
+ * @param {string} font Original font string
+ * @param {number} newSize New size in pixels
+ * @returns {string} New font string
+ */
+function setFontSize(font, newSize) {
+  const regex = /(\d+(?:\.\d+)?)\s*px/i;
+  return font.replace(regex, `${newSize}px`);
+}
+
+/**
+ * Calculate scale factor to fit content in fixed dimensions
+ * @param {number} contentWidth Natural content width
+ * @param {number} contentHeight Natural content height
+ * @param {number} availableWidth Available width
+ * @param {number} availableHeight Available height
+ * @returns {number} Scale factor (1 = no scaling needed)
+ */
+function calculateScaleFactor(contentWidth, contentHeight, availableWidth, availableHeight) {
+  const widthScale = availableWidth / contentWidth;
+  const heightScale = availableHeight / contentHeight;
+  return Math.min(widthScale, heightScale, 1);
+}
+
 module.exports = text2png;
+
+module.exports.text2png = text2png;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@igxjs/text2png",
-  "version": "3.0.2",
+  "version": "3.0.4",
   "description": "Convert text to png for node.js",
   "main": "index.js",
   "bin": {
@@ -13,7 +13,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/ibm-garage-experience/text2png.git"
+    "url": "git+https://github.com/igxjs/text2png.git"
   },
   "keywords": [
     "text",
@@ -22,16 +22,17 @@
   "publishConfig": {
     "access": "public"
   },
-  "author": "tkrkts <tkrkt2773@gmail.com> (http://github.com/tkrkt)",
+  "author": "Michael",
   "license": "MIT",
   "bugs": {
-    "url": "https://github.com/ibm-garage-experience/text2png/issues"
+    "url": "https://github.com/igxjs/text2png/issues"
   },
-  "homepage": "https://github.com/ibm-garage-experience/text2png#readme",
+  "homepage": "https://github.com/igxjs/text2png#readme",
   "files": [
     "bin",
     "README.md",
     "index.js",
+    "types.d.ts",
     "package.json",
     "LICENSE"
   ],

package/types.d.ts

@@ -0,0 +1,94 @@
+import { Readable } from 'node:stream';
+import { Canvas } from 'canvas';
+
+export interface Text2PngOptions {
+  /** CSS style font (default: "30px sans-serif") */
+  font?: string;
+  
+  /** Text alignment (default: "left") */
+  textAlign?: "left" | "center" | "right" | "start" | "end";
+  
+  /** Text color (default: "black") */
+  color?: string;
+  
+  /** Text color (alias for color, default: "black") */
+  textColor?: string;
+  
+  /** Background color */
+  backgroundColor?: string;
+  
+  /** Background color (alias for backgroundColor) */
+  bgColor?: string;
+  
+  /** Line spacing (default: 0) */
+  lineSpacing?: number;
+  
+  /** Stroke width (default: 0) */
+  strokeWidth?: number;
+  
+  /** Stroke color (default: "white") */
+  strokeColor?: string;
+  
+  /** Padding for all sides (default: 0) */
+  padding?: number;
+  
+  /** Left padding */
+  paddingLeft?: number;
+  
+  /** Top padding */
+  paddingTop?: number;
+  
+  /** Right padding */
+  paddingRight?: number;
+  
+  /** Bottom padding */
+  paddingBottom?: number;
+  
+  /** Border width for all sides (default: 0) */
+  borderWidth?: number;
+  
+  /** Left border width (default: 0) */
+  borderLeftWidth?: number;
+  
+  /** Top border width (default: 0) */
+  borderTopWidth?: number;
+  
+  /** Right border width (default: 0) */
+  borderRightWidth?: number;
+  
+  /** Bottom border width (default: 0) */
+  borderBottomWidth?: number;
+  
+  /** Border color (default: "black") */
+  borderColor?: string;
+  
+  /** Path to local font file (e.g., fonts/Lobster-Regular.ttf) */
+  localFontPath?: string;
+  
+  /** Name of local font (e.g., Lobster) */
+  localFontName?: string;
+  
+  /** Output type (default: "buffer") */
+  output?: "buffer" | "stream" | "dataURL" | "canvas";
+
+  /** Enable or disable image smoothing (default: false) */
+  imageSmoothingEnabled?: boolean;
+
+  /** Fixed width in pixels (optional, defaults to auto-calculated) */
+  width?: number;
+
+  /** Fixed height in pixels (optional, defaults to auto-calculated) */
+  height?: number;
+
+  /** Minimum font size when auto-scaling to fit fixed dimensions (default: 8) */
+  minFontSize?: number;
+
+  /** Vertical alignment when height is fixed (default: "middle") */
+  verticalAlign?: "top" | "middle" | "bottom";
+}
+
+declare function text2png(text: string, options?: Text2PngOptions): string | Buffer | Readable | Canvas;
+
+export default text2png;
+
+export { text2png };