@k4la/library 1.0.0

package/lib/blackjack.js

@@ -0,0 +1,219 @@
+/**
+ * @file lib/utils/blackjack.js
+ * @description Blackjack game utilities
+ * @author K4lameety
+ */
+
+const jimp = require('jimp')
+
+const CARDS_URL = "https://raw.githubusercontent.com/hayeah/playing-cards-assets/master/png/"
+
+const gameData = {}
+
+const createSession = (id) => {
+    gameData[id] = {
+        id: id,
+        status: 'waiting',
+        deck: [],
+        dealer: [], 
+        player: [], 
+        winner: null
+    }
+    return gameData[id]
+}
+
+const getSession = (id) => gameData[id] || false
+const deleteSession = (id) => delete gameData[id]
+
+const generateDeck = () => {
+    const suits = ['clubs', 'diamonds', 'hearts', 'spades']
+    const values = ['ace', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'jack', 'queen', 'king']
+    let deck = []
+
+    for (let suit of suits) {
+        for (let val of values) {
+            let score = parseInt(val)
+            if (val === 'ace') score = 11
+            if (['jack', 'queen', 'king'].includes(val)) score = 10
+
+            let filename = `${val}_of_${suit}.png`
+
+            deck.push({
+                id: filename,
+                value: val,
+                suit: suit,
+                score: score
+            })
+        }
+    }
+    for (let i = deck.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [deck[i], deck[j]] = [deck[j], deck[i]]
+    }
+    return deck
+}
+
+const calculateScore = (hand) => {
+    let score = 0
+    let aceCount = 0
+
+    for (let card of hand) {
+        score += card.score
+        if (card.value === 'ace') aceCount++
+    }
+
+    while (score > 21 && aceCount > 0) {
+        score -= 10
+        aceCount--
+    }
+    return score
+}
+
+const startGame = (id) => {
+    let session = getSession(id)
+    if (!session) session = createSession(id)
+    
+    session.status = 'playing'
+    session.deck = generateDeck()
+    session.player = []
+    session.dealer = []
+
+    session.player.push(session.deck.pop())
+    session.dealer.push(session.deck.pop())
+    session.player.push(session.deck.pop())
+    session.dealer.push(session.deck.pop())
+
+    let pScore = calculateScore(session.player)
+    if (pScore === 21) {
+        session.status = 'end'
+        session.winner = 'player_blackjack'
+    }
+
+    return session
+}
+
+const hit = (id) => {
+    let session = getSession(id)
+    if (!session || session.status !== 'playing') return { status: 'error' }
+
+    let card = session.deck.pop()
+    session.player.push(card)
+
+    let score = calculateScore(session.player)
+    if (score > 21) {
+        session.status = 'end'
+        return { status: 'bust', card, score }
+    }
+
+    return { status: 'ok', card, score }
+}
+
+const stand = (id) => {
+    let session = getSession(id)
+    if (!session || session.status !== 'playing') return { status: 'error' }
+
+    let dealerScore = calculateScore(session.dealer)
+    
+    while (dealerScore < 17) {
+        session.dealer.push(session.deck.pop())
+        dealerScore = calculateScore(session.dealer)
+    }
+
+    let playerScore = calculateScore(session.player)
+    session.status = 'end'
+
+    let result = ''
+    if (dealerScore > 21) result = 'dealer_bust' 
+    else if (playerScore > dealerScore) result = 'win'
+    else if (playerScore < dealerScore) result = 'lose'
+    else result = 'push' 
+
+    return { status: result, dealerScore, playerScore }
+}
+
+const canvas = async (id) => {
+    let session = getSession(id)
+    if (!session) return null
+
+    let bg = new jimp(800, 600, 0x35654dFF) 
+    let font = await jimp.loadFont(jimp.FONT_SANS_32_WHITE)
+    let fontBig = await jimp.loadFont(jimp.FONT_SANS_64_WHITE)
+
+    let cardBack = new jimp(120, 175, 0x800000FF)
+    let border = new jimp(110, 165, 0xFFFFFF22)
+    cardBack.composite(border, 5, 5)
+
+    let dx = 50
+    let dy = 50
+    let dealerScore = 0
+
+    for (let i = 0; i < session.dealer.length; i++) {
+        if (session.status === 'playing' && i === 1) {
+            bg.composite(cardBack, dx, dy)
+        } else {
+            try {
+                let url = CARDS_URL + session.dealer[i].id
+                let img = await jimp.read(url)
+                img.resize(120, 175)
+                bg.composite(img, dx, dy)
+            } catch (e) {
+                bg.print(font, dx, dy, session.dealer[i].value)
+            }
+        }
+        dx += 130
+    }
+
+    if (session.status === 'playing') {
+        bg.print(font, 50, 240, `Dealer: ${session.dealer[0].score} + ?`)
+    } else {
+        dealerScore = calculateScore(session.dealer)
+        bg.print(font, 50, 240, `Dealer: ${dealerScore}`)
+    }
+
+    let px = 50
+    let py = 350
+    for (let card of session.player) {
+        try {
+            let url = CARDS_URL + card.id
+            let img = await jimp.read(url)
+            img.resize(120, 175)
+            bg.composite(img, px, py)
+        } catch (e) {
+            bg.print(font, px, py, card.value)
+        }
+        px += 130
+    }
+
+    let playerScore = calculateScore(session.player)
+    bg.print(font, 50, 540, `Player: ${playerScore}`)
+
+    if (session.status === 'end') {
+        let text = ""
+        let color = 0
+        
+        if (session.winner === 'player_blackjack') text = "BLACKJACK!"
+        else if (playerScore > 21) text = "BUSTED!"
+        else if (dealerScore > 21) text = "DEALER BUST!"
+        else if (playerScore > dealerScore) text = "YOU WIN!"
+        else if (playerScore < dealerScore) text = "YOU LOSE!"
+        else text = "PUSH"
+
+        let overlay = new jimp(800, 150, 0x000000AA)
+        bg.composite(overlay, 0, 225)
+        
+        let textWidth = jimp.measureText(fontBig, text)
+        bg.print(fontBig, 400 - (textWidth / 2), 265, text)
+    }
+
+    return await bg.getBufferAsync(jimp.MIME_JPEG)
+}
+
+module.exports = {
+    createSession,
+    startGame,
+    hit,
+    stand,
+    getSession,
+    deleteSession,
+    canvas
+}

package/lib/converter.js

@@ -0,0 +1,105 @@
+/**
+ * @file lib/converter.js
+ * @description Media conversion utilities using ffmpeg
+ * @author K4lameety
+ */
+
+const fs = require('fs')
+const path = require('path')
+const { spawn } = require('child_process')
+const os = require('os')
+
+let ffmpegPath;
+try {
+    ffmpegPath = require('@ffmpeg-installer/ffmpeg').path;
+} catch (e) {
+    ffmpegPath = 'ffmpeg';
+}
+
+function ffmpeg(buffer, args = [], ext = '', ext2 = '') {
+  return new Promise(async (resolve, reject) => {
+    try {
+      let tmp = path.join(os.tmpdir(), Date.now() + '.' + ext)
+      let out = tmp + '.' + ext2
+      
+      await fs.promises.writeFile(tmp, buffer)
+      
+      spawn(ffmpegPath, [
+        '-y',
+        '-i', tmp,
+        ...args,
+        out
+      ])
+        .on('error', reject)
+        .on('close', async (code) => {
+          try {
+            await fs.promises.unlink(tmp)
+            if (code !== 0) return reject(code)
+            
+            const result = await fs.promises.readFile(out)
+            
+            await fs.promises.unlink(out)
+            
+            resolve(result)
+          } catch (e) {
+            reject(e)
+          }
+        })
+    } catch (e) {
+      reject(e)
+    }
+  })
+}
+
+/**
+ * Convert Audio/Video to MP3
+ * @param {Buffer} buffer 
+ * @param {String} ext 
+ */
+function toAudio(buffer, ext) {
+  return ffmpeg(buffer, [
+    '-vn',
+    '-ac', '2',
+    '-b:a', '128k',
+    '-ar', '44100',
+    '-f', 'mp3'
+  ], ext, 'mp3')
+}
+
+/**
+ * Convert Audio to Voice Note (Opus/PTT)
+ * @param {Buffer} buffer 
+ * @param {String} ext 
+ */
+function toPTT(buffer, ext) {
+  return ffmpeg(buffer, [
+    '-vn',
+    '-c:a', 'libopus',
+    '-b:a', '128k',
+    '-vbr', 'on',
+    '-compression_level', '10'
+  ], ext, 'opus')
+}
+
+/**
+ * Convert Video to MP4
+ * @param {Buffer} buffer 
+ * @param {String} ext 
+ */
+function toVideo(buffer, ext) {
+  return ffmpeg(buffer, [
+    '-c:v', 'libx264',
+    '-c:a', 'aac',
+    '-ab', '128k',
+    '-ar', '44100',
+    '-crf', '32',
+    '-preset', 'slow'
+  ], ext, 'mp4')
+}
+
+module.exports = {
+  toAudio,
+  toPTT,
+  toVideo,
+  ffmpeg,
+}

package/lib/exif.js

@@ -0,0 +1,205 @@
+/**
+ * @file lib/exif.js
+ * @description Functions to handle EXIF metadata for WebP images and stickers
+ * @author K4lameety
+ */
+
+const fs = require('fs')
+const { tmpdir } = require("os")
+const Crypto = require("crypto")
+const ffmpegPath = require('@ffmpeg-installer/ffmpeg').path
+const ff = require('fluent-ffmpeg')
+const webp = require("node-webpmux")
+const path = require("path")
+
+ff.setFfmpegPath(ffmpegPath)
+
+async function imageToWebp(media) {
+    const tmpFileOut = path.join(tmpdir(), `${Crypto.randomBytes(6).readUIntLE(0, 6).toString(36)}.webp`)
+    const tmpFileIn = path.join(tmpdir(), `${Crypto.randomBytes(6).readUIntLE(0, 6).toString(36)}.jpg`)
+
+    fs.writeFileSync(tmpFileIn, media)
+
+    await new Promise((resolve, reject) => {
+        ff(tmpFileIn)
+            .on("error", reject)
+            .on("end", () => resolve(true))
+            .addOutputOptions([
+                "-vcodec",
+                "libwebp",
+                "-vf",
+                "scale='min(320,iw)':min'(320,ih)':force_original_aspect_ratio=decrease,fps=15, pad=320:320:-1:-1:color=white@0.0, split [a][b]; [a] palettegen=reserve_transparent=on:transparency_color=ffffff [p]; [b][p] paletteuse"
+            ])
+            .toFormat("webp")
+            .save(tmpFileOut)
+    })
+
+    const buff = fs.readFileSync(tmpFileOut)
+    fs.unlinkSync(tmpFileOut)
+    fs.unlinkSync(tmpFileIn)
+    return buff
+}
+
+async function videoToWebp(media) {
+    const tmpFileOut = path.join(tmpdir(), `${Crypto.randomBytes(6).readUIntLE(0, 6).toString(36)}.webp`)
+    const tmpFileIn = path.join(tmpdir(), `${Crypto.randomBytes(6).readUIntLE(0, 6).toString(36)}.mp4`)
+
+    fs.writeFileSync(tmpFileIn, media)
+
+    await new Promise((resolve, reject) => {
+        ff(tmpFileIn)
+            .on("error", reject)
+            .on("end", () => resolve(true))
+            .addOutputOptions([
+                "-vcodec",
+                "libwebp",
+                "-vf",
+                "scale='min(320,iw)':min'(320,ih)':force_original_aspect_ratio=decrease,fps=15, pad=320:320:-1:-1:color=white@0.0, split [a][b]; [a] palettegen=reserve_transparent=on:transparency_color=ffffff [p]; [b][p] paletteuse",
+                "-loop",
+                "0",
+                "-ss",
+                "00:00:00",
+                "-t",
+                "00:00:05",
+                "-preset",
+                "default",
+                "-an",
+                "-vsync",
+                "0"
+            ])
+            .toFormat("webp")
+            .save(tmpFileOut)
+    })
+
+    const buff = fs.readFileSync(tmpFileOut)
+    fs.unlinkSync(tmpFileOut)
+    fs.unlinkSync(tmpFileIn)
+    return buff
+}
+
+async function writeExifImg(media, metadata) {
+    let wMedia = await imageToWebp(media)
+    const tmpFileIn = path.join(tmpdir(), `${Crypto.randomBytes(6).readUIntLE(0, 6).toString(36)}.webp`)
+    const tmpFileOut = path.join(tmpdir(), `${Crypto.randomBytes(6).readUIntLE(0, 6).toString(36)}.webp`)
+    fs.writeFileSync(tmpFileIn, wMedia)
+
+    if (metadata.packname || metadata.author) {
+        const img = new webp.Image()
+        const json = {
+            "sticker-pack-id": metadata.packId || `com.k4lameety.sticker`, // ID Default
+            "sticker-pack-name": metadata.packname,
+            "sticker-pack-publisher": metadata.author,
+            "emojis": metadata.categories ? metadata.categories : [""]
+        }
+        const exifAttr = Buffer.from([0x49, 0x49, 0x2A, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, 0x00, 0x41, 0x57, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00])
+        const jsonBuff = Buffer.from(JSON.stringify(json), "utf-8")
+        const exif = Buffer.concat([exifAttr, jsonBuff])
+        exif.writeUIntLE(jsonBuff.length, 14, 4)
+        await img.load(tmpFileIn)
+        fs.unlinkSync(tmpFileIn)
+        img.exif = exif
+        await img.save(tmpFileOut)
+        return tmpFileOut
+    }
+}
+
+async function writeExifVid(media, metadata) {
+    let wMedia = await videoToWebp(media)
+    const tmpFileIn = path.join(tmpdir(), `${Crypto.randomBytes(6).readUIntLE(0, 6).toString(36)}.webp`)
+    const tmpFileOut = path.join(tmpdir(), `${Crypto.randomBytes(6).readUIntLE(0, 6).toString(36)}.webp`)
+    fs.writeFileSync(tmpFileIn, wMedia)
+
+    if (metadata.packname || metadata.author) {
+        const img = new webp.Image()
+        const json = {
+            "sticker-pack-id": metadata.packId || `com.k4lameety.sticker`,
+            "sticker-pack-name": metadata.packname,
+            "sticker-pack-publisher": metadata.author,
+            "emojis": metadata.categories ? metadata.categories : [""]
+        }
+        const exifAttr = Buffer.from([0x49, 0x49, 0x2A, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, 0x00, 0x41, 0x57, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00])
+        const jsonBuff = Buffer.from(JSON.stringify(json), "utf-8")
+        const exif = Buffer.concat([exifAttr, jsonBuff])
+        exif.writeUIntLE(jsonBuff.length, 14, 4)
+        await img.load(tmpFileIn)
+        fs.unlinkSync(tmpFileIn)
+        img.exif = exif
+        await img.save(tmpFileOut)
+        return tmpFileOut
+    }
+}
+
+async function writeExif(media, metadata) {
+    let wMedia = /webp/.test(media.mimetype) ? media.data : /image/.test(media.mimetype) ? await imageToWebp(media.data) : /video/.test(media.mimetype) ? await videoToWebp(media.data) : ""
+    const tmpFileIn = path.join(tmpdir(), `${Crypto.randomBytes(6).readUIntLE(0, 6).toString(36)}.webp`)
+    const tmpFileOut = path.join(tmpdir(), `${Crypto.randomBytes(6).readUIntLE(0, 6).toString(36)}.webp`)
+    fs.writeFileSync(tmpFileIn, wMedia)
+
+    if (metadata.packname || metadata.author) {
+        const img = new webp.Image()
+        const json = {
+            "sticker-pack-id": metadata.packId || `com.k4lameety.sticker`,
+            "sticker-pack-name": metadata.packname,
+            "sticker-pack-publisher": metadata.author,
+            "emojis": metadata.categories ? metadata.categories : [""]
+        }
+        const exifAttr = Buffer.from([0x49, 0x49, 0x2A, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, 0x00, 0x41, 0x57, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00])
+        const jsonBuff = Buffer.from(JSON.stringify(json), "utf-8")
+        const exif = Buffer.concat([exifAttr, jsonBuff])
+        exif.writeUIntLE(jsonBuff.length, 14, 4)
+        await img.load(tmpFileIn)
+        fs.unlinkSync(tmpFileIn)
+        img.exif = exif
+        await img.save(tmpFileOut)
+        return tmpFileOut
+    }
+}
+
+async function exifAvatar(buffer, packname, author, categories = [''], extra = {}) {
+    const img = new webp.Image() // Menggunakan require di atas, bukan import dinamis
+    const stickerPackId = extra.packId || Crypto.randomBytes(32).toString('hex')
+    const json = {
+        'sticker-pack-id': stickerPackId,
+        'sticker-pack-name': packname,
+        'sticker-pack-publisher': author,
+        'emojis': categories,
+        'is-avatar-sticker': 1,
+        ...extra
+    }
+    let exifAttr = Buffer.from([0x49, 0x49, 0x2A, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, 0x00, 0x41, 0x57, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00])
+    let jsonBuffer = Buffer.from(JSON.stringify(json), 'utf8')
+    let exif = Buffer.concat([exifAttr, jsonBuffer])
+    exif.writeUIntLE(jsonBuffer.length, 14, 4)
+    await img.load(buffer)
+    img.exif = exif
+    return await img.save(null)
+}
+
+async function addExif(webpSticker, packname, author, categories = [''], extra = {}) {
+    const img = new webp.Image()
+    const stickerPackId = extra.packId || Crypto.randomBytes(32).toString('hex')
+    const json = {
+        'sticker-pack-id': stickerPackId,
+        'sticker-pack-name': packname,
+        'sticker-pack-publisher': author,
+        'emojis': categories,
+        ...extra
+    }
+    let exifAttr = Buffer.from([0x49, 0x49, 0x2A, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, 0x00, 0x41, 0x57, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00])
+    let jsonBuffer = Buffer.from(JSON.stringify(json), 'utf8')
+    let exif = Buffer.concat([exifAttr, jsonBuffer])
+    exif.writeUIntLE(jsonBuffer.length, 14, 4)
+    await img.load(webpSticker)
+    img.exif = exif
+    return await img.save(null)
+}
+
+module.exports = {
+    imageToWebp,
+    videoToWebp,
+    writeExifImg,
+    writeExifVid,
+    writeExif,
+    exifAvatar,
+    addExif
+}

package/lib/function.js

@@ -0,0 +1,13 @@
+/**
+ * @file lib/function.js
+ * @description General utility functions
+ * @author K4lameety
+ */
+
+function formatRupiah(angka) {
+    return "Rp " + angka.toLocaleString('id-ID');
+}
+
+module.exports = {
+    formatRupiah
+};

package/lib/game.js

@@ -0,0 +1,58 @@
+/**
+ * @file lib/game.js
+ * @description Game database handler
+ * @author K4lameety
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const pickRandom = (arr) => {
+    return arr[Math.floor(Math.random() * arr.length)];
+};
+
+const asahOtakDb = require('../data/asahotak.json');
+const susunKataDb = require('../data/susunkata.json');
+const tebakBenderaDb = require('../data/tebakbendera.json');
+const tebakKimiaDb = require('../data/tebakkimia.json');
+const tebakKataDb = require('../data/tebakkata.json');
+const tebakGambarDb = require('../data/tebakgambar.json');
+const family100Db = require('../data/family100.json');
+
+function asahOtak() {
+    return pickRandom(asahOtakDb);
+}
+
+function susunKata() {
+    return pickRandom(susunKataDb);
+}
+
+function tebakBendera() {
+    return pickRandom(tebakBenderaDb);
+}
+
+function tebakKimia() {
+    return pickRandom(tebakKimiaDb);
+}
+
+function tebakKata() {
+    return pickRandom(tebakKataDb);
+}
+
+function tebakGambar() {
+    return pickRandom(tebakGambarDb);
+}
+
+function family100() {
+    return pickRandom(family100Db);
+}
+
+module.exports = {
+    asahOtak,
+    susunKata,
+    tebakBendera,
+    tebakKimia,
+    tebakKata,
+    tebakGambar,
+    family100
+};