MetaData Extractor

Author: ShibamDey69

bun.lockb

@@ -10,7 +10,9 @@
   "author": "Shibam Dey",
   "license": "MIT",
   "dependencies": {
-    "file-type": "^19.0.0"
+    "file-type": "^19.0.0",
+    "node-webpmux": "^3.2.0",
+    "wa-sticker-formatter": "^4.4.4"
   },
   "devDependencies": {
     "@types/node": "^20.10.0",

package-lock.json

@@ -6,20 +6,23 @@ import { MetaDataType } from "./types/metaInfoType";
 import { StickerTypes } from "./types/StickerTypes";
 import MetaInfoChanger from "./lib/changeMetaInfo";
 import extractMetaData from "./lib/extractMetaData";
+
 class Sticker {
   private buffer: Buffer;
   private mimeType: string | undefined;
   private extType: string | undefined;
   private utils = new Utils();
   private outBuffer: Buffer;
-
+  private activeBuff: boolean;
+  private activeMeta: boolean;
   constructor(
     private data: Buffer | string | Readable,
     public metaInfo: Partial<MetaDataType> = {},
   ) {
     this.buffer = Buffer.from([]);
     this.outBuffer = Buffer.from([]);
-    this.metaInfo = this.metaInfo;
+    this.activeBuff = false;
+    this.activeMeta = false;
   }
 
   /**
@@ -36,9 +39,9 @@ class Sticker {
       this.extType = fileType?.ext;
       // Set default values for metaInfo if not provided
       this.metaInfo.pack = this.metaInfo.pack ?? "";
-      this.metaInfo.author = this.metaInfo.author ?? "";
-      this.metaInfo.id = this.metaInfo.id ?? this.utils.getId();
-      this.metaInfo.category = this.metaInfo.category ?? [];
+      this.metaInfo.author = this.metaInfo.author || "";
+      this.metaInfo.id = this.metaInfo.id || this.utils.getId();
+      this.metaInfo.category = this.metaInfo.category || [];
       this.metaInfo.type = this.metaInfo.type ?? StickerTypes.DEFAULT;
       this.metaInfo.quality =
         this.metaInfo?.quality ?? this.utils.getQuality(this.buffer);
@@ -55,14 +58,17 @@ class Sticker {
   public async toBuffer(): Promise<Buffer> {
     try {
       await this.initialize();
-      this.outBuffer = await convert(
+      let buffer = await convert(
         this.buffer,
         this.metaInfo,
         this.extType,
         this.mimeType,
       );
+      this.outBuffer = await new MetaInfoChanger(this.metaInfo).add(buffer);
+      this.activeBuff = true;
       return this.outBuffer ?? Buffer.from([]);
     } catch (error) {
+       this.activeBuff = false;
        throw new Error(`Conversion to buffer failed: ${error}`);
     }
   }
@@ -74,6 +80,9 @@ class Sticker {
    */
   public async toFile(outputPath: string): Promise<void> {
     try {
+      if (!this.activeBuff && !this.activeMeta) {
+        await this.changeMetaInfo()
+      }
       await fs.promises.writeFile(outputPath, this.outBuffer);
     } catch (error) {
       console.error(`Error converting to file: ${error}`);
@@ -82,27 +91,29 @@ class Sticker {
   }
 
   public async changeMetaInfo(
-    newMetaInfo: Partial<any | undefined>
+    newMetaInfo: Partial<any> = {}
   ) : Promise<any | undefined> {
     try {
       await this.initialize()
       this.metaInfo = { ...this.metaInfo, ...newMetaInfo };
-      this.outBuffer = MetaInfoChanger(this.buffer, this.metaInfo);
+      this.outBuffer = await new MetaInfoChanger(this.metaInfo).add(this.buffer);
+      this.activeMeta = true;
       return this.outBuffer;
     } catch (error) {
+      this.activeMeta = false;
       throw new Error(`Error changing meta info: ${error}`);
     }
   }
 
-  public async extractMetaData () {
+  public async extractMetaData (data:Buffer) {
     try {
       await this.initialize();
-      let metaData = extractMetaData(this.buffer);
+      let metaData = extractMetaData(data);
       return metaData;
     } catch (error) {
       throw new Error(`Error extracting meta data: ${error}`);
     }
   }
 }
 
-export default { Sticker, StickerTypes };
+export default { Sticker, StickerTypes };

package.json

@@ -1,4 +1,4 @@
-import { exec, spawn } from "child_process";
+import { exec } from "child_process";
 import { join } from "path";
 import { readFile, writeFile, unlink } from "fs/promises";
 import { tmpdir } from "os";
@@ -23,15 +23,15 @@ const ToWebp = async (
   mimeExt: string | undefined,
   mimeType: string | undefined,
 ): Promise<Buffer> => {
-  let inputPath = join(tmpdir(), `${Date.now()}.${mimeExt}`);
-  const outputPath = join(tmpdir(), `${Date.now()}.webp`);
+  let inputPath = join(tmpdir(), `${Date.now()}input.${mimeExt}`);
+  const outputPath = join(tmpdir(), `${Date.now()}output.webp`);
 
   try {
     // Write input buffer to temporary file
     await writeFile(inputPath, buffer);
     inputPath = mimeType?.includes("video")
-    ? await toGif(inputPath)
-    : inputPath;
+      ? await toGif(inputPath)
+      : inputPath;
     // Construct arguments for ffmpeg conversion
     const args: string[] = [
       "-i",
@@ -65,18 +65,6 @@ const ToWebp = async (
             mimeExt === "gif" ? "-lossless 1" : "-lossless 0",
           ].join(" ")
         : "-c:v libwebp",
-      metaInfo.author
-        ? `-metadata sticker-pack-publisher="${metaInfo.author}"`
-        : "",
-      metaInfo.pack ? `-metadata sticker-pack-name="${metaInfo.pack}"` : "",
-      metaInfo.id ? `-metadata sticker-pack-id="${metaInfo.id}"` : "",
-      metaInfo.quality ? `-metadata sticker-quality="${metaInfo.quality}"` : "",
-      metaInfo.background
-        ? `-metadata sticker-background-color="${metaInfo.background}"`
-        : "",
-      metaInfo.category?.length
-        ? `-metadata emojis="${metaInfo.category.join(",")}"`
-        : "",
       "-q:v",
       metaInfo.quality?.toString() ?? "50",
       "-y",
@@ -92,7 +80,7 @@ const ToWebp = async (
     throw new Error(`Conversion failed: ${error}`);
   } finally {
     // Cleanup temporary files
-    await cleanup(inputPath, outputPath);
+    await cleanup(inputPath, outputPath).catch((e) => console.error(e));
   }
 };
 

src/index.ts

@@ -1,23 +1,74 @@
-import { MetaDataType } from "../types/metaInfoType";
-import { StickerTypes } from "../types/StickerTypes";
-
-function changeMetaInfo(data: Buffer, metaInfo: Partial<MetaDataType>): Buffer {
-  try {
-    const type = metaInfo.type === StickerTypes.CIRCLE
-      ? "circle"
-      : metaInfo.type === StickerTypes.SQUARE
-      ? "square"
-      : metaInfo.type === StickerTypes.FIT
-      ? "fit"
-      : "default";
-
-    const updatedMetaData: MetaDataType = { type, ...restMetaInfo };
-    const metaDataString = JSON.stringify(updatedMetaData);
-    const updatedData = Buffer.concat([data, Buffer.from(metaDataString)]);
-    return updatedData;
-  } catch (error: unknown) {
-    throw new Error(`Error changing meta info: ${error}`);
-  }
-}
-
-export default changeMetaInfo;
+import Image from "node-webpmux";
+import { TextEncoder } from "util";
+
+/**
+ * The Exif class is responsible for handling the metadata (Exif data)
+ * for sticker images, particularly those used in messaging applications.
+ */
+export default class Exif {
+    private data: any = {};
+    private exif: Buffer | null = null;
+
+    /**
+     * Constructs an Exif instance with the given options.
+     * @param options - An object containing metadata for the sticker.
+     */
+    constructor(options: any) {
+        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.data["sticker-quality"] = options.quality || "30";
+        this.data["sticker-background"] = options.background || "";
+        this.data = { ...this.data, ...options };
+    }
+
+    /**
+     * Builds the Exif metadata as a Buffer.
+     * @returns A Buffer containing the constructed Exif data.
+     */
+    build = (): Buffer => {
+        const data = JSON.stringify(this.data);
+
+        // Construct the Exif header and data sections.
+        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"),
+        ]);
+
+        // Write the length of the data into the Exif header.
+        exif.writeUIntLE(new TextEncoder().encode(data).length, 14, 4);
+        return exif;
+    };
+
+    /**
+     * Adds the Exif metadata to the given image.
+     * @param image - A Buffer or Image instance representing the image to which Exif data should be added.
+     * @returns A Promise that resolves to a Buffer containing the image with the added Exif data.
+     */
+    add = async (image: Buffer | Image.Image): Promise<Buffer> => {
+        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 this.load(image);
+
+        // Set the Exif data on the image and save it.
+        image.exif = exif;
+        return await image.save(null);
+    };
+
+    /**
+     * Loads the image from a Buffer or string and returns an Image instance.
+     * @param image - A Buffer or string representing the image to be loaded.
+     * @returns A Promise that resolves to an Image instance.
+     */
+    load = async (image: Buffer | string): Promise<Image.Image> => {
+        const img = new Image.Image();
+        await img.load(image);
+        return img;
+    };
+}

src/lib/ToWebp.ts

@@ -1,50 +1,13 @@
-
-interface Metadata {
-    [key: string]: string;
-}
-
-function readCustomMetadata(buffer: Buffer): Metadata | null {
-    try {
-        if (buffer.slice(0, 4).toString('hex') !== '52494646') {
-            throw new Error('Buffer does not contain WebP format');
-        }
-
-        let offset = 12;
-        while (offset < buffer.length) {
-            const chunkID = buffer.slice(offset, offset + 4).toString('ascii');
-            const chunkSize = buffer.readUIntLE(offset + 4, 4);
-            if (chunkID === 'VP8X' || chunkID === 'EXIF' || chunkID === 'ICCP') {
-                const metadataStartOffset = offset + 8;
-                const metadata = buffer.slice(metadataStartOffset, metadataStartOffset + chunkSize);
-                console.log(metadataStartOffset)
-                const parsedMetadata = parseMetadataBuffer(metadata);
-                return parsedMetadata;
-            }
-
-            offset += 8 + chunkSize;
-        }
-
-        throw new Error('No custom metadata found in WebP file');
-
-    } catch (error: unknown) {
-        console.error('Error reading WebP custom metadata:', error);
-        return null;
-    }
-}
-
-function parseMetadataBuffer(metadata: Buffer): Metadata {
-    const metadataString = metadata.toString('utf8');
-    const parsedMetadata: Metadata = {};
-    const lines = metadataString.split('\n');
-    lines.forEach(line => {
-        const keyValue = line.split(':');
-        if (keyValue.length === 2) {
-            const key = keyValue[0].trim();
-            const value = keyValue[1].trim();
-            parsedMetadata[key] = value;
-        }
-    });
-    return parsedMetadata;
+import Image from 'node-webpmux'
+/**
+ * Extracts metadata from a WebP image.
+ * @param {Buffer}image - The image buffer to extract metadata from
+ */
+ const extractMetadata = async (image: Buffer): Promise<any> => {
+    const img = new Image.Image()
+    await img.load(image)
+    const exif = img.exif?.toString('utf-8') ?? '{}'
+    return JSON.parse(exif.substring(exif.indexOf('{'), exif.lastIndexOf('}') + 1) ?? '{}');
 }
 
-export default readCustomMetadata;
+export default extractMetadata;

src/lib/changeMetaInfo.ts

@@ -0,0 +1,8 @@
+declare module 'node-webpmux' {
+    export class Image {
+        constructor()
+        exif: Buffer
+        load(buffer: Buffer | string): Promise<void>
+        save(...args: unknown[]): Promise<Buffer>
+    }
+}