medias-fakerator 1.0.0-dra → 1.0.0-dra.0

package/lib/quote-generator.js

@@ -2,12 +2,31 @@ const fs = require("fs");
 const path = require("path");
 const runes = require("runes");
 const sharp = require("sharp");
-const EmojiDbLib = require("emoji-db");
 const { LRUCache } = require("lru-cache");
-const emojiDb = new EmojiDbLib({ useDefaultDb: true });
 const emojiImageByBrandPromise = require("emoji-cache");
 const ALLOWED_MEDIA_DIRECTORY = path.resolve(__dirname, "../");
 const { createCanvas, loadImage, registerFont } = require("canvas");
+const emoji = require("node-emoji");
+const emojiRegex =
+  /(\p{Extended_Pictographic}(?:\u200d\p{Extended_Pictographic})*)/gu;
+
+function searchEmojiFromText(text) {
+  const results = [];
+  let match;
+
+  while ((match = emojiRegex.exec(text)) !== null) {
+    const emojiChar = match[0];
+
+    results.push({
+      emoji: emojiChar, // emoji unicode
+      found: emojiChar, // key untuk emoji-cache
+      offset: match.index,
+      length: emojiChar.length,
+    });
+  }
+
+  return results;
+}
 
 async function loadFont() {
   const fontsDir = path.join(__dirname, "../assets/fonts");
@@ -338,10 +357,8 @@ class QuoteGenerate {
       for (let i = 0; i < charStyles.length; i++) charStyles[i].push(entities);
     }
     const styledWords = [];
-    const emojiData = emojiDb.searchFromText({
-      input: text,
-      fixCodePoints: true,
-    });
+    const emojiData = searchEmojiFromText(text);
+
     let currentIndex = 0;
     const processPlainText = (plainText, startOffset) => {
       if (!plainText) return;
@@ -540,10 +557,8 @@ class QuoteGenerate {
       }
     }
     const styledWords = [];
-    const emojiData = emojiDb.searchFromText({
-      input: text,
-      fixCodePoints: true,
-    });
+    const emojiData = searchEmojiFromText(text);
+
     let currentIndex = 0;
     const processPlainText = (plainText, startOffset) => {
       if (!plainText) return;

package/lib/utils.js

@@ -1,66 +1,115 @@
-const EmojiDbLib = require('emoji-db');
+const emojiRegex =
+  /(\p{Extended_Pictographic}(?:\u200d\p{Extended_Pictographic})*)/gu;
 
-let emojiDb;
-try {
-  emojiDb = new EmojiDbLib({ useDefaultDb: true });
-  if (!emojiDb || typeof emojiDb.searchFromText !== 'function') throw new Error('Gagal menginisialisasi database emoji');
-} catch (error) {
-  console.error('Error saat inisialisasi database emoji:', error);
-  throw error;
+function searchEmojiFromText(text) {
+  const results = [];
+  let match;
+
+  while ((match = emojiRegex.exec(text)) !== null) {
+    const emojiChar = match[0];
+    results.push({
+      found: emojiChar,
+      emoji: emojiChar,
+      offset: match.index,
+      length: emojiChar.length,
+    });
+  }
+
+  return results;
 }
 
 function parseTextToSegments(text, ctx, fontSize) {
   try {
-    if (typeof text !== 'string') text = String(text);
-    if (!ctx || typeof ctx.measureText !== 'function') throw new TypeError('Invalid canvas context');
+    if (typeof text !== "string") text = String(text);
+    if (!ctx || typeof ctx.measureText !== "function")
+      throw new TypeError("Invalid canvas context");
     const finalSegments = [];
-    const rawLines = text.split('\n');
+    const rawLines = text.split("\n");
     rawLines.forEach((line, index) => {
-      if (line === '') {
+      if (line === "") {
       } else {
         const segmentsInLine = [];
-        const emojiMatches = emojiDb.searchFromText({ input: line, fixCodePoints: true });
+        const emojiMatches = searchEmojiFromText(line);
+
         let lastIndex = 0;
         const processChunk = (chunk) => {
           if (!chunk) return;
-          const tokenizerRegex = /(\*_.*?_\*|_\*.*?\*_)|(\*.*?\*)|(_.*?_)|(~.*?~)|(```.*?```)|(\s+)|([^\s*~_`]+)/g;
+          const tokenizerRegex =
+            /(\*_.*?_\*|_\*.*?\*_)|(\*.*?\*)|(_.*?_)|(~.*?~)|(```.*?```)|(\s+)|([^\s*~_`]+)/g;
           let match;
           while ((match = tokenizerRegex.exec(chunk)) !== null) {
-            const [fullMatch, boldItalic, bold, italic, strikethrough, monospace, whitespace, textContent] = match;
+            const [
+              fullMatch,
+              boldItalic,
+              bold,
+              italic,
+              strikethrough,
+              monospace,
+              whitespace,
+              textContent,
+            ] = match;
             if (boldItalic) {
               const content = boldItalic.slice(2, -2);
               ctx.font = `italic bold ${fontSize}px Arial`;
-              segmentsInLine.push({ type: 'bolditalic', content, width: ctx.measureText(content).width });
+              segmentsInLine.push({
+                type: "bolditalic",
+                content,
+                width: ctx.measureText(content).width,
+              });
             } else if (bold) {
               const content = bold.slice(1, -1);
               ctx.font = `bold ${fontSize}px Arial`;
-              segmentsInLine.push({ type: 'bold', content, width: ctx.measureText(content).width });
+              segmentsInLine.push({
+                type: "bold",
+                content,
+                width: ctx.measureText(content).width,
+              });
             } else if (italic) {
               const content = italic.slice(1, -1);
               ctx.font = `italic ${fontSize}px Arial`;
-              segmentsInLine.push({ type: 'italic', content, width: ctx.measureText(content).width });
+              segmentsInLine.push({
+                type: "italic",
+                content,
+                width: ctx.measureText(content).width,
+              });
             } else if (strikethrough) {
               const content = strikethrough.slice(1, -1);
               ctx.font = `${fontSize}px Arial`;
-              segmentsInLine.push({ type: 'strikethrough', content, width: ctx.measureText(content).width });
+              segmentsInLine.push({
+                type: "strikethrough",
+                content,
+                width: ctx.measureText(content).width,
+              });
             } else if (monospace) {
               const content = monospace.slice(3, -3);
               ctx.font = `${fontSize}px 'Courier New', monospace`;
-              segmentsInLine.push({ type: 'monospace', content, width: ctx.measureText(content).width });
+              segmentsInLine.push({
+                type: "monospace",
+                content,
+                width: ctx.measureText(content).width,
+              });
             } else if (whitespace) {
               ctx.font = `${fontSize}px Arial`;
-              segmentsInLine.push({ type: 'whitespace', content: whitespace, width: ctx.measureText(whitespace).width });
+              segmentsInLine.push({
+                type: "whitespace",
+                content: whitespace,
+                width: ctx.measureText(whitespace).width,
+              });
             } else if (textContent) {
               ctx.font = `${fontSize}px Arial`;
-              segmentsInLine.push({ type: 'text', content: textContent, width: ctx.measureText(textContent).width });
+              segmentsInLine.push({
+                type: "text",
+                content: textContent,
+                width: ctx.measureText(textContent).width,
+              });
             }
           }
         };
-        emojiMatches.forEach(emojiInfo => {
+        emojiMatches.forEach((emojiInfo) => {
           const plainText = line.substring(lastIndex, emojiInfo.offset);
           processChunk(plainText);
           segmentsInLine.push({
-            type: 'emoji',
+            type: "emoji",
             content: emojiInfo.found,
             width: fontSize * 1.2,
           });
@@ -72,13 +121,13 @@ function parseTextToSegments(text, ctx, fontSize) {
         finalSegments.push(...segmentsInLine);
       }
       if (index < rawLines.length - 1) {
-        finalSegments.push({ type: 'newline', content: '\n', width: 0 });
+        finalSegments.push({ type: "newline", content: "\n", width: 0 });
       }
     });
     ctx.font = `${fontSize}px Arial`;
     return finalSegments;
   } catch (error) {
-    console.error('Error in parseTextToSegments:', error);
+    console.error("Error in parseTextToSegments:", error);
     return [];
   }
 }
@@ -90,50 +139,70 @@ function rebuildLinesFromSegments(segments, maxWidth, ctx, fontSize) {
     let currentLineWidth = 0;
     const getFontString = (type, size) => {
       switch (type) {
-        case 'bold': return `bold ${size}px Arial`;
-        case 'italic': return `italic ${size}px Arial`;
-        case 'bolditalic': return `italic bold ${size}px Arial`;
-        case 'monospace': return `${size}px 'Courier New', monospace`;
-        default: return `${size}px Arial`;
+        case "bold":
+          return `bold ${size}px Arial`;
+        case "italic":
+          return `italic ${size}px Arial`;
+        case "bolditalic":
+          return `italic bold ${size}px Arial`;
+        case "monospace":
+          return `${size}px 'Courier New', monospace`;
+        default:
+          return `${size}px Arial`;
       }
     };
-    segments.forEach(segment => {
-      if (segment.type === 'newline') {
+    segments.forEach((segment) => {
+      if (segment.type === "newline") {
         lines.push(currentLine);
         currentLine = [];
         currentLineWidth = 0;
         return;
       }
-      if (segment.width > maxWidth && segment.type !== 'emoji') {
+      if (segment.width > maxWidth && segment.type !== "emoji") {
         if (currentLine.length > 0) {
           lines.push(currentLine);
           currentLine = [];
           currentLineWidth = 0;
         }
-        let tempStr = '';
+        let tempStr = "";
         const originalFont = getFontString(segment.type, fontSize);
         ctx.font = originalFont;
         for (const char of segment.content) {
           const measuredWidth = ctx.measureText(tempStr + char).width;
           if (measuredWidth > maxWidth) {
-            lines.push([{ type: segment.type, content: tempStr, width: ctx.measureText(tempStr).width }]);
+            lines.push([
+              {
+                type: segment.type,
+                content: tempStr,
+                width: ctx.measureText(tempStr).width,
+              },
+            ]);
             tempStr = char;
           } else {
             tempStr += char;
           }
         }
         if (tempStr) {
-          currentLine = [{ type: segment.type, content: tempStr, width: ctx.measureText(tempStr).width }];
+          currentLine = [
+            {
+              type: segment.type,
+              content: tempStr,
+              width: ctx.measureText(tempStr).width,
+            },
+          ];
           currentLineWidth = currentLine[0].width;
         }
         return;
       }
-      if (currentLineWidth + segment.width > maxWidth && currentLine.length > 0) {
+      if (
+        currentLineWidth + segment.width > maxWidth &&
+        currentLine.length > 0
+      ) {
         lines.push(currentLine);
         currentLine = [segment];
         currentLineWidth = segment.width;
       } else {
-        if (segment.type === 'whitespace' && currentLine.length === 0) return;
+        if (segment.type === "whitespace" && currentLine.length === 0) return;
         currentLine.push(segment);
         currentLineWidth += segment.width;
       }
@@ -143,24 +212,24 @@ function rebuildLinesFromSegments(segments, maxWidth, ctx, fontSize) {
     }
     return lines;
   } catch (error) {
-    console.error('Error in rebuildLinesFromSegments:', error);
+    console.error("Error in rebuildLinesFromSegments:", error);
     return [[]];
   }
 }
 
 function getContrastColor(hexColor) {
-  if (!hexColor || typeof hexColor !== 'string') return '#FFFFFF';
-  const hex = hexColor.replace('#', '');
-  if (hex.length !== 6) return '#FFFFFF';
+  if (!hexColor || typeof hexColor !== "string") return "#FFFFFF";
+  const hex = hexColor.replace("#", "");
+  if (hex.length !== 6) return "#FFFFFF";
   const r = parseInt(hex.substring(0, 2), 16);
   const g = parseInt(hex.substring(2, 4), 16);
   const b = parseInt(hex.substring(4, 6), 16);
-  const luminance = (0.299 * r + 0.587 * g + 0.114 * b);
-  return luminance > 140 ? '#000000' : '#FFFFFF';
-};
+  const luminance = 0.299 * r + 0.587 * g + 0.114 * b;
+  return luminance > 140 ? "#000000" : "#FFFFFF";
+}
 
 module.exports = {
   parseTextToSegments,
   rebuildLinesFromSegments,
-  getContrastColor
-};
+  getContrastColor,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "medias-fakerator",
-  "version": "1.0.0-dra",
+  "version": "1.0.0-dra.0",
   "description": "AIO Faker generator by Iruka Devs",
   "main": "index.js",
   "author": "Iruka Devs",
@@ -11,10 +11,10 @@
     "@ffmpeg-installer/ffmpeg": "1.1.0",
     "canvas": "^3.2.0",
     "emoji-cache": "^2.0.1",
-    "emoji-db": "github:Terror-Machine/emoji-db#master",
     "fluent-ffmpeg": "^2.1.3",
     "fs-extra": "11.3.2",
     "lru-cache": "^11.1.0",
+    "node-emoji": "^2.2.0",
     "runes": "^0.4.3",
     "sharp": "^0.34.3"
   },