@open-discord-bots/framework 0.0.1 → 0.0.2

package/src/api/modules/stat.ts

@@ -0,0 +1,313 @@
+///////////////////////////////////////
+//STAT MODULE
+///////////////////////////////////////
+import { ODId, ODManager, ODManagerData, ODSystemError, ODValidId } from "./base"
+import { ODDebugger } from "./console"
+import { ODDatabase, ODJsonDatabaseStructure } from "./database"
+import * as discord from "discord.js"
+
+/**## ODValidStatValue `type`
+ * These are the only allowed types for a stat value to improve compatibility with different database systems.
+ */
+export type ODValidStatValue = string|number|boolean
+
+/**## ODStatsManagerInitCallback `type`
+ * This callback can be used to execute something when the stats have been initiated.
+ * 
+ * By default this is used to clear stats from users that left the server or tickets which don't exist anymore.
+ */
+export type ODStatsManagerInitCallback = (database:ODJsonDatabaseStructure, deletables:ODJsonDatabaseStructure) => void|Promise<void>
+
+/**## ODStatScopeSetMode `type`
+ * This type contains all valid methods for changing the value of a stat.
+ */
+export type ODStatScopeSetMode = "set"|"increase"|"decrease"
+
+/**## ODStatsManager `class`
+ * This is an Open Discord stats manager.
+ * 
+ * This class is responsible for managing all stats of the bot.
+ * Stats are categorized in "scopes" which can be accessed in this manager.
+ * 
+ * Stats can be accessed in the individual scopes.
+ */
+export class ODStatsManager extends ODManager<ODStatScope> {
+    /**Alias to Open Discord debugger. */
+    #debug: ODDebugger
+    /**Alias to Open Discord stats database. */
+    database: ODDatabase|null = null
+    /**All the listeners for the init event. */
+    #initListeners: ODStatsManagerInitCallback[] = []
+
+    constructor(debug:ODDebugger){
+        super(debug,"stat scope")
+        this.#debug = debug
+    }
+
+    /**Select the database to use to read/write all stats from/to. */
+    useDatabase(database:ODDatabase){
+        this.database = database
+    }
+    add(data:ODStatScope, overwrite?:boolean): boolean {
+        data.useDebug(this.#debug,"stat")
+        if (this.database) data.useDatabase(this.database)
+        return super.add(data,overwrite)
+    }
+    /**Init all stats and run `onInit()` listeners. */
+    async init(){
+        if (!this.database) throw new ODSystemError("Unable to initialize stats scopes due to missing database!")
+
+        //get all valid categories
+        const validCategories: string[] = []
+        for (const scope of this.getAll()){
+            validCategories.push(...scope.init())
+        }
+
+        //filter out the deletable stats
+        const deletableStats: ODJsonDatabaseStructure = []
+        const data = await this.database.getAll()
+        data.forEach((data) => {
+            if (!validCategories.includes(data.category)) deletableStats.push(data)
+        })
+
+        //do additional deletion
+        for (const cb of this.#initListeners){
+            await cb(data,deletableStats)
+        }
+        
+        //delete all deletable stats
+        for (const data of deletableStats){
+            if (!this.database) return
+            await this.database.delete(data.category,data.key)
+        }
+    }
+    /**Reset all stats. (clears the entire database) */
+    async reset(){
+        if (!this.database) return
+        const data = await this.database.getAll()
+        for (const d of data){
+            if (!this.database) return
+            await this.database.delete(d.category,d.key)
+        }
+    }
+    /**Run a function when the stats are initialized. This can be used to clear stats from users that left the server or tickets which don't exist anymore. */
+    onInit(callback:ODStatsManagerInitCallback){
+        this.#initListeners.push(callback)
+    }
+}
+
+/**## ODStatScope `class`
+ * This is an Open Discord stat scope.
+ * 
+ * A scope can contain multiple stats. Every scope is seperated from other scopes.
+ * Here, you can read & write the values of all stats.
+ * 
+ * The built-in Open Discord scopes are: `global`, `user`, `ticket`
+ */
+export class ODStatScope extends ODManager<ODStat> {
+    /**The id of this statistics scope. */
+    id: ODId
+    /**Is this stat scope already initialized? */
+    ready: boolean = false
+    /**Alias to Open Discord stats database. */
+    database: ODDatabase|null = null
+    /**The name of this scope (used in embed title) */
+    name:string
+
+    constructor(id:ODValidId, name:string){
+        super()
+        this.id = new ODId(id)
+        this.name = name
+    }
+
+    /**Select the database to use to read/write all stats from/to. (Automatically assigned when used in `ODStatsManager`) */
+    useDatabase(database:ODDatabase){
+        this.database = database
+    }
+    /**Get the value of a statistic. The `scopeId` is the unique id of the user, channel, role, etc that the stats are related to. */
+    async getStat(id:ODValidId, scopeId:string): Promise<ODValidStatValue|null> {
+        if (!this.database) return null
+        const newId = new ODId(id)
+        const data = await this.database.get(this.id.value+"_"+newId.value,scopeId)
+
+        if (typeof data == "undefined"){
+            //set stats to default value & return
+            return this.resetStat(id,scopeId)
+        }else if (typeof data == "string" || typeof data == "boolean" || typeof data == "number"){
+            //return value received from database
+            return data
+        }
+        //return null on error
+        return null
+    }
+    /**Get the value of a statistic for all `scopeId`'s. The `scopeId` is the unique id of the user, channel, role, etc that the stats are related to. */
+    async getAllStats(id:ODValidId): Promise<{id:string,value:ODValidStatValue}[]> {
+        if (!this.database) return []
+        const newId = new ODId(id)
+        const data = await this.database.getCategory(this.id.value+"_"+newId.value) ?? []
+        const output: {id:string,value:ODValidStatValue}[] = []
+
+        for (const stat of data){
+            if (typeof stat.value == "string" || typeof stat.value == "boolean" || typeof stat.value == "number"){
+                //return value received from database
+                output.push({id:stat.key,value:stat.value})
+            }
+        }
+        
+        //return null on error
+        return output
+    }
+    /**Set, increase or decrease the value of a statistic. The `scopeId` is the unique id of the user, channel, role, etc that the stats are related to. */
+    async setStat(id:ODValidId, scopeId:string, value:ODValidStatValue, mode:ODStatScopeSetMode): Promise<boolean> {
+        if (!this.database) return false
+        const stat = this.get(id)
+        if (!stat) return false
+        if (mode == "set" || typeof value != "number"){
+            await this.database.set(this.id.value+"_"+stat.id.value,scopeId,value)
+        }else if (mode == "increase"){
+            const currentValue = await this.getStat(id,scopeId)
+            if (typeof currentValue != "number") await this.database.set(this.id.value+"_"+stat.id.value,scopeId,0+value)
+            else await this.database.set(this.id.value+"_"+stat.id.value,scopeId,currentValue+value)
+        }else if (mode == "decrease"){
+            const currentValue = await this.getStat(id,scopeId)
+            if (typeof currentValue != "number") await this.database.set(this.id.value+"_"+stat.id.value,scopeId,0-value)
+            else await this.database.set(this.id.value+"_"+stat.id.value,scopeId,currentValue-value)
+        }
+        return true
+    }
+    /**Reset the value of a statistic to the initial value. The `scopeId` is the unique id of the user, channel, role, etc that the stats are related to. */
+    async resetStat(id:ODValidId, scopeId:string): Promise<ODValidStatValue|null> {
+        if (!this.database) return null
+        const stat = this.get(id)
+        if (!stat) return null
+        if (stat.value != null) await this.database.set(this.id.value+"_"+stat.id.value,scopeId,stat.value)
+        return stat.value
+    }
+    /**Initialize this stat scope & return a list of all statistic ids in the following format: `<scopeid>_<statid>`  */
+    init(): string[] {
+        //get all valid stats categories
+        this.ready = true
+        return this.getAll().map((stat) => this.id.value+"_"+stat.id.value)
+    }
+    /**Render all stats in this scope for usage in a discord message/embed. */
+    async render(scopeId:string, guild:discord.Guild, channel:discord.TextBasedChannel, user:discord.User): Promise<string> {
+        //sort from high priority to low
+        const derefArray = [...this.getAll()]
+        derefArray.sort((a,b) => {
+            return b.priority-a.priority
+        })
+        const result: string[] = []
+
+        for (const stat of derefArray){
+            try {
+                if (stat instanceof ODDynamicStat){
+                    //dynamic render (without value)
+                    result.push(await stat.render("",scopeId,guild,channel,user))
+                }else{
+                    //normal render (with value)
+                    const value = await this.getStat(stat.id,scopeId)
+                    if (value != null) result.push(await stat.render(value,scopeId,guild,channel,user))
+                }
+                
+            }catch(err){
+                process.emit("uncaughtException",err)
+            }
+        }
+
+        return result.filter((stat) => stat !== "").join("\n")
+    }
+}
+
+/**## ODStatGlobalScope `class`
+ * This is an Open Discord stat global scope.
+ * 
+ * A scope can contain multiple stats. Every scope is seperated from other scopes.
+ * Here, you can read & write the values of all stats.
+ * 
+ * This scope is made specifically for the global stats of Open Discord.
+ */
+export class ODStatGlobalScope extends ODStatScope {
+    getStat(id:ODValidId): Promise<ODValidStatValue|null> {
+        return super.getStat(id,"GLOBAL")
+    }
+    getAllStats(id:ODValidId): Promise<{id:string,value:ODValidStatValue}[]> {
+        return super.getAllStats(id)
+    }
+    setStat(id:ODValidId, value:ODValidStatValue, mode:ODStatScopeSetMode): Promise<boolean> {
+        return super.setStat(id,"GLOBAL",value,mode)
+    }
+    resetStat(id:ODValidId): Promise<ODValidStatValue|null> {
+        return super.resetStat(id,"GLOBAL")
+    }
+    render(scopeId:"GLOBAL", guild:discord.Guild, channel:discord.TextBasedChannel, user: discord.User): Promise<string> {
+        return super.render("GLOBAL",guild,channel,user)
+    }
+}
+
+/**## ODStatRenderer `type`
+ * This callback will render a single statistic for a discord embed/message.
+ */
+export type ODStatRenderer = (value:ODValidStatValue, scopeId:string, guild:discord.Guild, channel:discord.TextBasedChannel, user:discord.User) => string|Promise<string>
+
+/**## ODStat `class`
+ * This is an Open Discord statistic.
+ * 
+ * This single statistic doesn't do anything except defining the rules of this statistic.
+ * Use it in a stats scope to register a new statistic. A statistic can also include a priority to choose the render priority.
+ * 
+ * It's recommended to use the `ODBasicStat` & `ODDynamicStat` classes instead of this one!
+ */
+export class ODStat extends ODManagerData {
+    /**The priority of this statistic. */
+    priority: number
+    /**The render function of this statistic. */
+    render: ODStatRenderer
+    /**The value of this statistic. */
+    value: ODValidStatValue|null
+
+    constructor(id:ODValidId, priority:number, render:ODStatRenderer, value?:ODValidStatValue){
+        super(id)
+        this.priority = priority
+        this.render = render
+        this.value = value ?? null
+    }
+}
+
+/**## ODBasicStat `class`
+ * This is an Open Discord basic statistic.
+ * 
+ * This single statistic will store a number, boolean or string in the database.
+ * Use it to create a simple statistic for any stats scope.
+ */
+export class ODBasicStat extends ODStat {
+    /**The name of this stat. Rendered in discord embeds/messages. */
+    name: string
+
+    constructor(id:ODValidId, priority:number, name:string, value:ODValidStatValue){
+        super(id,priority,(value) => {
+            return ""+name+": `"+value.toString()+"`"
+        },value)
+        this.name = name
+    }
+}
+
+/**## ODDynamicStatRenderer `type`
+ * This callback will render a single dynamic statistic for a discord embed/message.
+ */
+export type ODDynamicStatRenderer = (scopeId:string, guild:discord.Guild, channel:discord.TextBasedChannel, user:discord.User) => string|Promise<string>
+
+/**## ODDynamicStat `class`
+ * This is an Open Discord dynamic statistic.
+ * 
+ * A dynamic statistic does not store anything in the database! Instead, it will execute a function to return a custom result.
+ * This can be used to show statistics which are not stored in the database.
+ * 
+ * This is used in Open Discord for the live ticket status, participants & system status.
+ */
+export class ODDynamicStat extends ODStat {
+    constructor(id:ODValidId, priority:number, render:ODDynamicStatRenderer){
+        super(id,priority,(value,scopeId,guild,channel,user) => {
+            return render(scopeId,guild,channel,user)
+        })
+    }
+}

package/src/api/modules/verifybar.ts

@@ -0,0 +1,61 @@
+///////////////////////////////////////
+//VERIFYBAR MODULE
+///////////////////////////////////////
+import { ODId, ODManager, ODManagerData, ODValidId } from "./base"
+import { ODMessage } from "./builder"
+import { ODDebugger } from "./console"
+import { ODButtonResponderInstance } from "./responder"
+import * as discord from "discord.js"
+import { ODWorkerManager } from "./worker"
+
+/**## ODVerifyBar `class`
+ * This is an Open Discord verifybar.
+ * 
+ * It is contains 2 sets of workers and a lot of utilities for the (✅ ❌) verifybars in the bot.
+ * 
+ * It doesn't contain the code which activates or spawns the verifybars!
+ */
+export class ODVerifyBar extends ODManagerData {
+    /**All workers that will run when the verifybar is accepted. */
+    success: ODWorkerManager<ODButtonResponderInstance,"verifybar",{data:string|null,verifybarMessage:discord.Message<boolean>|null}>
+    /**All workers that will run when the verifybar is stopped. */
+    failure: ODWorkerManager<ODButtonResponderInstance,"verifybar",{data:string|null,verifybarMessage:discord.Message<boolean>|null}>
+    /**The message that will be built wen activating this verifybar. */
+    message: ODMessage<"verifybar",{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User,verifybar:ODVerifyBar,originalMessage:discord.Message<boolean>}>
+    /**When disabled, it will skip the verifybar and instantly fire the `success` workers. */
+    enabled: boolean
+
+    constructor(id:ODValidId, message:ODMessage<"verifybar",{guild:discord.Guild|null,channel:discord.TextBasedChannel,user:discord.User,originalMessage:discord.Message<boolean>}>, enabled?:boolean){
+        super(id)
+        this.success = new ODWorkerManager("descending")
+        this.failure = new ODWorkerManager("descending")
+        this.message = message
+        this.enabled = enabled ?? true
+    }
+
+    /**Build the message and reply to a button with this verifybar. */
+    async activate(responder:ODButtonResponderInstance){
+        if (this.enabled){
+            //show verifybar
+            const {guild,channel,user,message} = responder
+            await responder.update(await this.message.build("verifybar",{guild,channel,user,verifybar:this,originalMessage:message}))
+        }else{
+            //instant success
+            if (this.success) await this.success.executeWorkers(responder,"verifybar",{data:null,verifybarMessage:null})
+        }
+    }
+}
+
+/**## ODVerifyBarManager `class`
+ * This is an Open Discord verifybar manager.
+ * 
+ * It contains all (✅ ❌) verifybars in the bot.
+ * The `ODVerifyBar` classes contain `ODWorkerManager`'s that will be fired when the continue/stop buttons are pressed.
+ * 
+ * It doesn't contain the code which activates the verifybars! This should be implemented by your own.
+ */
+export class ODVerifyBarManager extends ODManager<ODVerifyBar> {
+    constructor(debug:ODDebugger){
+        super(debug,"verifybar")
+    }
+}

package/src/api/modules/worker.ts

@@ -0,0 +1,93 @@
+///////////////////////////////////////
+//WORKER MODULE
+///////////////////////////////////////
+import { ODId, ODManager, ODManagerData, ODValidId } from "./base"
+
+/**## ODWorkerCallback `type`
+ * This is the callback used in `ODWorker`!
+ */
+export type ODWorkerCallback<Instance, Source extends string, Params> = (instance:Instance, params:Params, source:Source, cancel:() => void) => void|Promise<void>
+
+/**## ODWorker `class`
+ * This is an Open Discord worker.
+ * 
+ * You can compare it with a normal javascript callback, but slightly more advanced!
+ * 
+ * - It has an `id` for identification of the function
+ * - A `priority` to know when to execute this callback (related to others)
+ * - It knows who called this callback (`source`)
+ * - And much more!
+ */
+export class ODWorker<Instance, Source extends string, Params> extends ODManagerData {
+    /**The priority of this worker */
+    priority: number
+    /**The main callback of this worker */
+    callback: ODWorkerCallback<Instance,Source,Params>
+
+    constructor(id:ODValidId, priority:number, callback:ODWorkerCallback<Instance,Source,Params>){
+        super(id)
+        this.priority = priority
+        this.callback = callback
+    }
+}
+
+/**## ODWorker `class`
+ * This is an Open Discord worker manager.
+ * 
+ * It manages & executes `ODWorker`'s in the correct order.
+ * 
+ * You can register a custom worker in this class to create a message or button.
+ */
+export class ODWorkerManager<Instance, Source extends string, Params> extends ODManager<ODWorker<Instance,Source,Params>> {
+    /**The order of execution for workers inside this manager. */
+    #priorityOrder: "ascending"|"descending"
+    /**The backup worker will be executed when one of the workers fails or cancels execution. */
+    backupWorker: ODWorker<{reason:"error"|"cancel"},Source,Params>|null = null
+    
+    constructor(priorityOrder:"ascending"|"descending"){
+        super()
+        this.#priorityOrder = priorityOrder
+    }
+    
+    /**Get all workers in sorted order. */
+    getSortedWorkers(priority:"ascending"|"descending"){
+        const derefArray = [...this.getAll()]
+
+        return derefArray.sort((a,b) => {
+            if (priority == "ascending") return a.priority-b.priority
+            else return b.priority-a.priority
+        })
+    }
+    /**Execute all workers on an instance using the given source & parameters. */
+    async executeWorkers(instance:Instance, source:Source, params:Params){
+        const derefParams = {...params}
+        const workers = this.getSortedWorkers(this.#priorityOrder)
+        let didCancel = false
+        let didCrash = false
+        
+        for (const worker of workers){
+            if (didCancel) break
+            try {
+                await worker.callback(instance,derefParams,source,() => {
+                    didCancel = true
+                })
+            }catch(err){
+                process.emit("uncaughtException",err)
+                didCrash = true
+            }
+        }
+        if (didCancel && this.backupWorker){
+            try{
+                await this.backupWorker.callback({reason:"cancel"},derefParams,source,() => {})
+            }catch(err){
+                process.emit("uncaughtException",err)
+            }
+        }else if (didCrash && this.backupWorker){
+            try{
+                await this.backupWorker.callback({reason:"error"},derefParams,source,() => {})
+            }catch(err){
+                process.emit("uncaughtException",err)
+            }
+        }
+    }
+}

package/src/api/utils.ts

@@ -0,0 +1,206 @@
+import * as fs from "fs"
+import ansis from "ansis"
+import * as api from "./api"
+
+/**## sharedFuses `utility variable`
+ * All shared fuses from Open Discord. Please use `opendiscord.sharedFuses` instead!
+ */
+export const sharedFuses: api.ODSharedFuseManager = new api.ODSharedFuseManager()
+
+/**## checkNodeVersion `utility function`
+ * Check if the node.js version is v20 or higher.
+ */
+export function checkNodeVersion(project:api.ODProjectType){
+    const nodev = process.versions.node.split(".")
+    if (Number(nodev[0]) < 20){
+        const title = (project == "openticket") ? "OPEN TICKET" : "OPEN MODERATION"
+        console.log("\n\n==============================\n["+title+" ERROR]: Invalid node.js version. Open Ticket requires node.js v20 or above!\n==============================\n\n")
+        process.exit(1)
+    }
+}
+
+/**## moduleInstalled `utility function`
+ * Use this function to check if an npm package is installed or not!
+ * @example utilities.moduleInstalled("discord.js") //check if discord.js is installed
+ */
+export function moduleInstalled(id:string,throwError?:boolean): boolean {
+    try{
+        require.resolve(id)
+        return true
+    }catch{
+        if (throwError) throw new Error("npm module \""+id+"\" is not installed! Install it via 'npm install "+id+"'")
+        return false
+    }
+}
+
+/**## initialStartupLogs `utility function`
+ * Use this function to check if an npm package is installed or not!
+ * @example utilities.moduleInstalled("discord.js") //check if discord.js is installed
+ */
+export function initialStartupLogs(opendiscord:api.ODMain,project:api.ODProjectType){
+    const title = (project == "openticket") ? "OPEN TICKET" : "OPEN MODERATION"
+    console.log("\n--------------------------- "+title+" STARTUP ---------------------------")
+    opendiscord.log("Logging system activated!","system")
+    opendiscord.debug.debug("Using Node.js "+process.version+"!")
+
+    try{
+        const packageJson = JSON.parse(fs.readFileSync("./package.json").toString())
+        opendiscord.debug.debug("Using discord.js "+packageJson.dependencies["discord.js"]+"!")
+        opendiscord.debug.debug("Using @discordjs/rest "+packageJson.dependencies["@discordjs/rest"]+"!")
+        opendiscord.debug.debug("Using ansis "+packageJson.dependencies["ansis"]+"!")
+        opendiscord.debug.debug("Using formatted-json-stringify "+packageJson.dependencies["formatted-json-stringify"]+"!")
+        opendiscord.debug.debug("Using terminal-kit "+packageJson.dependencies["terminal-kit"]+"!")
+        opendiscord.debug.debug("Using typescript "+packageJson.dependencies["typescript"]+"!")
+    }catch{
+        opendiscord.debug.debug("Failed to fetch module versions!")
+    }
+}
+
+/**## timer `utility function`
+ * Use this to wait for a certain amount of milliseconds. This only works when using `await`
+ * @example await utilities.timer(1000) //wait 1sec
+ */
+export async function timer(ms:number): Promise<void> {
+    return new Promise((resolve) => {
+        setTimeout(() => {
+            resolve()
+        },ms)
+    })
+}
+
+/**## emojiTitle `utility function`
+ * Use this function to create a title with an emoji before/after the text. The style & divider are set in `opendiscord.sharedFuses`
+ * @example utilities.emojiTitle("📎","Links") //create a title with an emoji based on the bot emoji style
+ */
+export function emojiTitle(emoji:string, text:string){
+    const style = sharedFuses.getFuse("emojiTitleStyle")
+    const divider = sharedFuses.getFuse("emojiTitleDivider")
+
+    if (style == "disabled") return text
+    else if (style == "before") return emoji+divider+text
+    else if (style == "after") return text+divider+emoji
+    else if (style == "double") return emoji+divider+text+divider+emoji
+    else return text
+}
+
+/**## runAsync `utility function`
+ * Use this function to run a snippet of code asyncronous without creating a separate function for it!
+ */
+export async function runAsync(func:() => Promise<void>): Promise<void> {
+    func()
+}
+
+/**## timedAwait `utility function`
+ * Use this function to await a promise but reject after the certain timeout has been reached.
+ */
+export function timedAwait<ReturnValue>(promise:ReturnValue,timeout:number,onError:(err:Error) => void): ReturnValue {
+    let allowResolve = true
+    return new Promise(async (resolve,reject) => {
+        //set timeout & stop if it is before the promise resolved
+        setTimeout(() => {
+            allowResolve = false
+            reject("utilities.timedAwait() => Promise Timeout")
+        },timeout)
+
+        //get promise result & return if not already rejected
+        try{
+            const res = await promise
+            if (allowResolve) resolve(res)
+        }catch(err){
+            onError(err)
+        }
+    return promise
+    }) as ReturnValue
+}
+
+/**## dateString `utility function`
+ * Use this function to create a short date string in the following format: `DD/MM/YYYY HH:MM:SS`
+ */
+export function dateString(date): string {
+    return `${date.getDate()}/${date.getMonth()+1}/${date.getFullYear()} ${date.getHours()}:${date.getMinutes()}:${date.getSeconds()}`
+}
+
+/**## asyncReplace `utility function`
+ * Same as `string.replace(search, value)` but with async compatibility
+ */
+export async function asyncReplace(text:string, regex:RegExp, func:(value:string,...args:any[]) => Promise<string>): Promise<string> {
+    const promises: Promise<string>[] = []
+    text.replace(regex,(match,...args) => {
+        promises.push(func(match,...args))
+        return match
+    })
+    const data = await Promise.all(promises)
+    const result = text.replace(regex,(match) => {
+        const replaceResult = data.shift()
+        return replaceResult ?? match
+    })
+    return result
+}
+
+/**## getLongestLength `utility function`
+ * Get the length of the longest string in the array.
+ */
+export function getLongestLength(texts:string[]): number {
+    return Math.max(...texts.map((t) => ansis.strip(t).length))
+}
+
+/**## ordinalNumber `utility function`
+ * Get a human readable ordinal number (e.g. 1st, 2nd, 3rd, 4th, ...) from a Javascript number.
+ */
+export function ordinalNumber(num:number){
+    const i = Math.abs(Math.round(num))
+    const cent = i % 100
+    if (cent >= 10 && cent <= 20) return i+'th'
+    const dec = i % 10
+    if (dec === 1) return i+'st'
+    if (dec === 2) return i+'nd'
+    if (dec === 3) return i+'rd'
+    return i+'th'
+}
+
+/**## trimEmojis `utility function`
+ * Trim/remove all emoji's from a Javascript string.
+ */
+export function trimEmojis(text){
+    return text.replace(/(\p{Extended_Pictographic}(?:\uFE0F|\uFE0E)?(?:\u200D\p{Extended_Pictographic}(?:\uFE0F|\uFE0E)?)*)/gu,"")
+}
+
+/**## easterEggs `utility object`
+ * Object containing data for Open Ticket easter eggs.
+ */
+export const easterEggs: api.ODEasterEggs = {
+    /* THANK YOU TO ALL OUR CONTRIBUTORS!!! */
+    creator:"779742674932072469", //DJj123dj
+    translators:[
+        "779742674932072469", //DJj123dj
+        "574172558006681601", //Sanke
+        "540639725300613136", //Guillee.3
+        "547231585368539136", //Mods HD
+        "664934139954331649", //SpyEye
+        "498055992962187264", //Redactado
+        "912052735950618705", //T0miiis
+        "366673202610569227", //johusens
+        "360780292853858306", //David.3
+        "950611418389024809", //Sarcastic
+        "461603955517161473", //Maurizo
+        "465111430274875402", //The_Gamer
+        "586376952470831104", //Erxg
+        "226695254433202176", //Mkevas
+        "437695615095275520", //NoOneNook
+        "530047191222583307", //Anderskiy
+        "719072181631320145", //ToStam
+        "1172870906377408512", //Stragar
+        "1084794575945744445", //Sasanwm
+        "449613814049275905", //Benzorich
+        "905373133085741146", //Ronalds
+        "918504977369018408", //Palestinian
+        "807970841035145216", //Kornel0706
+        "1198883915826475080", //Nova
+        "669988226819162133", //Danoglez
+        "1313597620996018271", //Fraden1
+        "547809968145956884", //TsgIndrius
+        "264120132660363267", //Quiradon
+        "1272034143777329215", //NotMega
+        "LOREMIPSUM", //TODO, ADD MORE IDS IN FUTURE!
+    ]
+}