@shibam/sticker-maker 1.3.0-rc1 → 1.3.0-rc3

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@shibam/sticker-maker",
-  "version": "1.3.0-rc1",
+  "version": "1.3.0-rc3",
   "description": "A package for creating stickers",
-  "main": "dist/index.js",
+  "main": "src/index.js",
   "type": "module",
   "files": [
-    "dist"
+    "src"
   ],
   "scripts": {},
   "author": "Shibam Dey",
@@ -24,7 +24,7 @@
     "typescript"
   ],
   "dependencies": {
-    "file-type": "^19.4.0",
+    "file-type": "^22.0.1",
     "fs-extra": "^11.3.5",
     "node-webpmux": "^3.2.0"
   }

package/src/index.js

@@ -0,0 +1,57 @@
+import fs from 'fs-extra'
+import Utils from './lib/utils.js'
+import ToWebp from './lib/ToWebp.js'
+import MetaInfoChanger from './lib/changeMetaInfo.js'
+
+export default class Sticker {
+    constructor(data, metaInfo = {}) {
+        this.data = data
+        this.metaInfo = { ...metaInfo }
+        this.utils = new Utils()
+        this.buffer = null
+        this.mimeType = ''
+        this.extType = ''
+        this.initialized = false
+    }
+
+    async initialize() {
+        if (this.initialized) return
+        this.buffer = await this.utils.buffer(this.data)
+        const fileType = await this.utils.getMimeType(this.buffer)
+        this.mimeType = fileType?.mime || ''
+        this.extType = fileType?.ext || ''
+        this.metaInfo.pack ??= ''
+        this.metaInfo.author ??= ''
+        this.metaInfo.id ??= this.utils.getId()
+        this.metaInfo.category ??= []
+        this.metaInfo.type ??= 'DEFAULT'
+        this.metaInfo.quality ??= this.utils.getQuality(this.buffer)
+        this.metaInfo.text ??= ''
+        this.initialized = true
+    }
+
+    async toBuffer() {
+        await this.initialize()
+        const toWebp = await ToWebp(this.buffer, this.metaInfo, this.extType, this.mimeType)
+        return new MetaInfoChanger(this.metaInfo).add(toWebp)
+    }
+
+    async toFile(outputPath) {
+        await this.initialize()
+        const buffer = this.extType === 'webp' ? await this.changeMetaInfo() : await this.toBuffer()
+        await fs.writeFile(outputPath, buffer)
+    }
+
+    async changeMetaInfo() {
+        await this.initialize()
+        return new MetaInfoChanger(this.metaInfo).add(this.buffer)
+    }
+}
+
+const StickerTypes = {
+    DEFAULT: 'DEFAULT',
+    CIRCLE: 'CIRCLE',
+    SQUARE: 'SQUARE'
+}
+export { default as extractMetaData } from './lib/extractMetaData.js'
+export { StickerTypes }

package/src/lib/ToWebp.js

@@ -0,0 +1,61 @@
+import { promisify } from 'util'
+import { execFile } from 'child_process'
+import fs from 'fs-extra'
+import os from 'os'
+import path from 'path'
+import toGif from './toGif.js'
+import TextOnImg from './textOnImg.js'
+
+const exec = promisify(execFile)
+const textOnImg = new TextOnImg()
+
+export default async function ToWebp(buffer, metaInfo, mimeExt, mimeType) {
+    const timestamp = Date.now()
+    const inputPath = path.join(os.tmpdir(), `input_${timestamp}.${mimeExt}`)
+    const outputPath = path.join(os.tmpdir(), `output_${timestamp}.webp`)
+
+    try {
+        if (mimeExt === 'webp') return buffer
+
+        let processedData = buffer
+        let currentExt = mimeExt
+        const isAnimated = mimeType?.includes('video') || mimeExt === 'gif'
+
+        if (mimeType?.includes('video')) {
+            processedData = await toGif(buffer, mimeExt, metaInfo.type || 'DEFAULT', metaInfo.text ?? '')
+            currentExt = 'gif'
+        } else if (metaInfo.text) {
+            processedData = await textOnImg.drawText(buffer, metaInfo.text)
+            currentExt = 'png'
+        }
+
+        await fs.writeFile(inputPath, processedData)
+
+        let videoFilter = ''
+        if (metaInfo.type === 'CIRCLE') {
+            videoFilter = 'scale=512:512:force_original_aspect_ratio=increase,crop=512:512,format=rgba,geq=r=\'r(X,Y)\':g=\'g(X,Y)\':b=\'b(X,Y)\':a=\'if(lte((X-256)*(X-256)+(Y-256)*(Y-256),65536),255,0)\''
+        } else if (metaInfo.type === 'SQUARE') {
+            videoFilter = 'scale=512:512:force_original_aspect_ratio=decrease'
+        } else {
+            videoFilter = 'scale=512:512:force_original_aspect_ratio=decrease'
+        }
+
+        const ffmpegArgs = ['-y', '-i', inputPath, '-vf', videoFilter]
+
+        if (isAnimated) {
+            ffmpegArgs.push('-loop', '0', '-pix_fmt', 'yuva420p')
+        }
+
+        ffmpegArgs.push(
+            '-c:v', 'libwebp',
+            '-quality', String(metaInfo.quality || 80),
+            '-lossless', currentExt === 'gif' ? '1' : '0',
+            outputPath
+        )
+
+        await exec('ffmpeg', ffmpegArgs)
+        return await fs.readFile(outputPath)
+    } finally {
+        await Promise.all([fs.remove(inputPath), fs.remove(outputPath)]).catch(() => {})
+    }
+}

package/src/lib/changeMetaInfo.js

@@ -0,0 +1,43 @@
+import Image from 'node-webpmux'
+import { TextEncoder } from 'util'
+
+export default class Exif {
+
+    constructor(options) {
+        this.data = {}
+        this.data['sticker-pack-id'] = options.id || ''
+        this.data['sticker-pack-name'] = options.pack || ''
+        this.data['sticker-pack-publisher'] = options.author || ''
+        this.data['emojis'] = options.category || ['😹']
+        this.exif = null
+    }
+
+    build = () => {
+        const data = JSON.stringify(this.data)
+        const exif = Buffer.concat([
+            Buffer.from([
+                0x49, 0x49, 0x2a, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, 0x00, 0x41, 0x57, 0x07, 0x00, 0x00, 0x00, 0x00,
+                0x00, 0x16, 0x00, 0x00, 0x00
+            ]),
+            Buffer.from(data, 'utf-8')
+        ])
+        exif.writeUIntLE(new TextEncoder().encode(data).length, 14, 4)
+        return exif
+    }
+
+    add = async (image) => {
+        const exif = this.exif || this.build()
+        
+        // Load the image if it is not already an instance of Image.Image.
+        image = image instanceof Image.Image
+            ? image
+            : await (async () => {
+                const img = new Image.Image()
+                await img.load(image)
+                return img
+            })()
+
+        image.exif = exif
+        return await image.save(null)
+    }
+}

package/src/lib/extractMetaData.js

@@ -0,0 +1,14 @@
+import Image from 'node-webpmux';
+import Utils from './utils.js';
+
+const utils = new Utils();
+const extractMetadata = async (image) => {
+    const img = new Image.Image();
+    const buffer = await utils.buffer(image);
+    const fileType = await utils.getMimeType(buffer);
+    if (!fileType || fileType.ext !== 'webp') throw new Error('Unsupported file type for metadata extraction');
+    await img.load(image);
+    const exif = img.exif?.toString('utf-8') ?? '{}';
+    return JSON.parse(exif.substring(exif.indexOf('{'), exif.lastIndexOf('}') + 1) ?? '{}');
+};
+export default extractMetadata;

package/src/lib/textOnGif.js

@@ -0,0 +1,98 @@
+import { promisify } from 'util'
+import { execFile } from 'child_process'
+import fs from 'fs-extra'
+import os from 'os'
+import path from 'path'
+
+const exec = promisify(execFile)
+
+export default class TextOnGif {
+    constructor(maxCharsPerLine = 20) {
+        this.maxCharsPerLine = maxCharsPerLine
+    }
+
+    wrapText(text, maxChars = 20) {
+        const words = text.split(' ')
+        const lines = []
+        let currentLine = ''
+        for (const word of words) {
+            const test = currentLine ? `${currentLine} ${word}` : word
+            if (test.length <= maxChars) currentLine = test
+            else {
+                if (currentLine) lines.push(currentLine)
+                currentLine = word.length > maxChars ? word.substring(0, maxChars) : word
+            }
+        }
+        if (currentLine) lines.push(currentLine)
+        return lines
+    }
+
+    escapeText(text) {
+        return text.replace(/'/g, "'\\''").replace(/:/g, '\\:').replace(/,/g, '\\,').replace(/%/g, '\\%')
+    }
+
+    escapeFontPath(fontPath) {
+        return fontPath
+            .replace(/\\/g, '/')
+            .replace(/:/g, '\\:')
+    }
+
+    getFontPath() {
+        const fonts = {
+            win32: [
+                'C:/Windows/Fonts/arialbd.ttf',
+                'C:/Windows/Fonts/arial.ttf',
+                'C:/Windows/Fonts/segoeui.ttf'
+            ],
+            darwin: [
+                '/Library/Fonts/Arial Bold.ttf',
+                '/System/Library/Fonts/Helvetica.ttc',
+                '/Library/Fonts/Arial.ttf'
+            ],
+            linux: [
+                '/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf',
+                '/usr/share/fonts/truetype/liberation/LiberationSans-Bold.ttf',
+                '/usr/share/fonts/truetype/freefont/FreeSansBold.ttf'
+            ]
+        }
+        const list = fonts[process.platform] || fonts.linux
+        for (const f of list) if (fs.existsSync(f)) return f
+        return 'arial.ttf'
+    }
+
+    async drawText(gifBuffer, text, padding = { x: 10, y: 10 }) {
+        const inputPath = path.join(os.tmpdir(), `input_${Date.now()}.gif`)
+        const outputPath = path.join(os.tmpdir(), `output_${Date.now()}.gif`)
+        const fontPath = this.escapeFontPath(this.getFontPath())
+
+        try {
+            await fs.writeFile(inputPath, gifBuffer)
+            const { stdout } = await exec('ffprobe', [
+                '-v', 'error',
+                '-select_streams', 'v:0',
+                '-show_entries', 'stream=width,height',
+                '-of', 'csv=p=0:s=x',
+                inputPath
+            ])
+            const [width, height] = stdout.trim().split('x').map(Number)
+            if (!width || !height) throw new Error('Invalid GIF dimensions')
+
+            const fontSize = Math.floor(height / 10)
+            const lineHeight = fontSize * 1.2
+            const lines = this.wrapText(text, this.maxCharsPerLine)
+
+            const filters = lines.map((line, i) => {
+                const y = Math.floor(height - padding.y - (lines.length - i) * lineHeight)
+                return `drawtext=fontfile='${fontPath}':text='${this.escapeText(line)}':x=(w-text_w)/2:y=${y}:fontsize=${fontSize}:fontcolor=white:borderw=2:bordercolor=black`
+            })
+
+            await exec('ffmpeg', ['-y', '-i', inputPath, '-vf', filters.join(','), '-c:v', 'gif', outputPath])
+            return await fs.readFile(outputPath)
+        } catch (err) {
+            console.error('TextOnGif error:', err.message)
+            throw err
+        } finally {
+            await Promise.all([fs.remove(inputPath), fs.remove(outputPath)]).catch(() => {})
+        }
+    }
+}

package/src/lib/textOnImg.js

@@ -0,0 +1,98 @@
+import { promisify } from 'util'
+import { execFile } from 'child_process'
+import fs from 'fs-extra'
+import os from 'os'
+import path from 'path'
+
+const exec = promisify(execFile)
+
+export default class TextOnImg {
+    constructor(maxCharsPerLine = 25) {
+        this.maxCharsPerLine = maxCharsPerLine
+    }
+
+    wrapText(text, maxChars = 25) {
+        const words = text.split(' ')
+        const lines = []
+        let currentLine = ''
+        for (const word of words) {
+            const test = currentLine ? `${currentLine} ${word}` : word
+            if (test.length <= maxChars) currentLine = test
+            else {
+                if (currentLine) lines.push(currentLine)
+                currentLine = word.length > maxChars ? word.substring(0, maxChars) : word
+            }
+        }
+        if (currentLine) lines.push(currentLine)
+        return lines
+    }
+
+    escapeText(text) {
+        return text.replace(/'/g, "'\\''").replace(/:/g, '\\:').replace(/,/g, '\\,').replace(/%/g, '\\%')
+    }
+
+    escapeFontPath(fontPath) {
+        return fontPath
+            .replace(/\\/g, '/')
+            .replace(/:/g, '\\:')
+    }
+
+    getFontPath() {
+        const fonts = {
+            win32: [
+                'C:/Windows/Fonts/arialbd.ttf',
+                'C:/Windows/Fonts/arial.ttf',
+                'C:/Windows/Fonts/segoeui.ttf'
+            ],
+            darwin: [
+                '/Library/Fonts/Arial Bold.ttf',
+                '/System/Library/Fonts/Helvetica.ttc',
+                '/Library/Fonts/Arial.ttf'
+            ],
+            linux: [
+                '/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf',
+                '/usr/share/fonts/truetype/liberation/LiberationSans-Bold.ttf',
+                '/usr/share/fonts/truetype/freefont/FreeSansBold.ttf'
+            ]
+        }
+        const list = fonts[process.platform] || fonts.linux
+        for (const f of list) if (fs.existsSync(f)) return f
+        return 'arial.ttf'
+    }
+
+    async drawText(imageBuffer, text, padding = { x: 10, y: 10 }) {
+        const inputPath = path.join(os.tmpdir(), `input_${Date.now()}.png`)
+        const outputPath = path.join(os.tmpdir(), `output_${Date.now()}.png`)
+        const fontPath = this.escapeFontPath(this.getFontPath())
+
+        try {
+            await fs.writeFile(inputPath, imageBuffer)
+            const { stdout } = await exec('ffprobe', [
+                '-v', 'error',
+                '-select_streams', 'v:0',
+                '-show_entries', 'stream=width,height',
+                '-of', 'csv=p=0:s=x',
+                inputPath
+            ])
+            const [width, height] = stdout.trim().split('x').map(Number)
+            if (!width || !height) throw new Error('Invalid image dimensions')
+
+            const fontSize = Math.floor(height / 10)
+            const lineHeight = fontSize * 1.2
+            const lines = this.wrapText(text, this.maxCharsPerLine)
+
+            const filters = lines.map((line, i) => {
+                const y = Math.floor(height - padding.y - (lines.length - i) * lineHeight)
+                return `drawtext=fontfile='${fontPath}':text='${this.escapeText(line)}':x=(w-text_w)/2:y=${y}:fontsize=${fontSize}:fontcolor=white:borderw=2:bordercolor=black`
+            })
+
+            await exec('ffmpeg', ['-y', '-i', inputPath, '-vf', filters.join(','), outputPath])
+            return await fs.readFile(outputPath)
+        } catch (err) {
+            console.error('TextOnImg error:', err.message)
+            throw err
+        } finally {
+            await Promise.all([fs.remove(inputPath), fs.remove(outputPath)]).catch(() => {})
+        }
+    }
+}

package/src/lib/toGif.js

@@ -0,0 +1,32 @@
+import { promisify } from 'util'
+import { execFile } from 'child_process'
+import fs from 'fs-extra'
+import os from 'os'
+import path from 'path'
+import TextOnGif from './textOnGif.js'
+
+
+const exec = promisify(execFile)
+const textOnGif = new TextOnGif()
+
+export default async function videoToGif(buffer, extType, type, text = '') {
+    for (let attempt = 0; attempt < 3; attempt++) {
+        const ts = Date.now()
+        const inputPath = path.join(os.tmpdir(), `in_${ts}_${attempt}.${extType}`)
+        const outputPath = path.join(os.tmpdir(), `out_${ts}_${attempt}.gif`)
+        try {
+            await fs.writeFile(inputPath, buffer)
+            const vf = type === 'SQUARE'
+                ? 'scale=320:-1:flags=lanczos,fps=10,crop=min(iw\\,ih):min(iw\\,ih)'
+                : 'scale=320:-1:flags=lanczos,fps=20'
+            await exec('ffmpeg', ['-y', '-i', inputPath, '-vf', vf, '-t', '7', '-loop', '0', '-f', 'gif', outputPath])
+            let result = await fs.readFile(outputPath)
+            if (text) result = await textOnGif.drawText(result, text)
+            return result
+        } catch (error) {
+            if (attempt === 2) throw error
+        } finally {
+            await Promise.all([fs.remove(inputPath), fs.remove(outputPath)]).catch(() => {})
+        }
+    }
+}

package/src/lib/utils.js

@@ -0,0 +1,37 @@
+import { Readable } from 'stream'
+import fs from 'fs-extra'
+export default class Utils {
+    async buffer(data) {
+        try {
+            if (typeof data === 'string') return await fs.readFile(data)
+            if (data instanceof Readable) return await this.streamToBuffer(data)
+            return Buffer.from(data)
+        } catch (error) {
+            throw new Error(`Error converting to buffer: ${error}`)
+        }
+    }
+    async streamToBuffer(stream) {
+        const chunks = []
+        return new Promise((resolve, reject) => {
+            stream.on('data', chunk => chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)))
+            stream.on('end', () => resolve(Buffer.concat(chunks)))
+            stream.on('error', reject)
+        })
+    }
+    getQuality(data) {
+        const bytes = Buffer.from(data).length / 1024
+        return bytes > 4096 ? 8 : bytes > 3072 ? 10 : bytes > 2048 ? 12 : 15
+    }
+    async getMimeType(data) {
+        try {
+            const { fileTypeFromBuffer } = await import('file-type')
+            return await fileTypeFromBuffer(data)
+        } catch (error) {
+            console.error(`Error getting MIME type: ${error}`)
+            return undefined
+        }
+    }
+    getId() {
+        return [...Array(5)].map(() => Math.random().toString(36).substring(2, 15)).join('')
+    }
+}