@open-discord-bots/framework 0.3.14 → 0.3.15

package/src/api/modules/state.ts

@@ -1,298 +0,0 @@
-///////////////////////////////////////
-//STATE MODULE
-///////////////////////////////////////
-import { ODId, ODManager, ODValidId, ODSystemError, ODManagerData, ODNoGeneric, ODValidJsonType } from "./base.js"
-import { ODClientManager } from "./client.js"
-import { ODDebugger } from "./console.js"
-import { ODDatabase, ODDatabaseIdConstraint } from "./database.js"
-import * as discord from "discord.js"
-
-/**## ODStateKey `type`
- * The key template for message states.
- */
-export type ODStateKey<WithGuildKey extends boolean,WithUserKey extends boolean> = {
-    /**A valid discord channel ID or instance. */
-    channel:discord.Channel|string,
-    /**A valid discord message ID or instance. */
-    message:discord.Message|string,
-}
-& (WithGuildKey extends true ? {
-    /**A valid discord server/guild ID or instance. */
-    guild:discord.Guild|string,
-} : {})
-& (WithUserKey extends true ? {
-    /**A valid discord user ID or instance. */
-    user:discord.User|discord.GuildMember|string
-} : {})
-
-/**## ODStateData `type`
- * The raw data template for message states used for storing in the database.
- */
-export interface ODStateData<StateData extends any> {
-    /**The linked Guild ID of this message state. */
-    guildId:string|null,
-    /**The linked Channel ID of this message state. */
-    channelId:string,
-    /**The linked Message ID of this message state. */
-    messageId:string,
-    /**The linked User ID of this message state. */
-    userId:string|null,
-    /**The creation date of this state (UNIX TIMESTAMP). */
-    createdDate:number,
-    /**The modified date of this state (UNIX TIMESTAMP). */
-    modifiedDate:number,
-    /**Optional date after which this state should be regarded as expired (UNIX TIMESTAMP). */
-    deleteAfterDate:number|null,
-    /**The state data. */
-    data:StateData
-}
-
-/**## ODStateSettings `type`
- * Configurable settings for an ODState.
- */
-export interface ODStateSettings {
-    /**(Default: `false`) Completely disable autodelete of message states. (unless manually activated using other settings) */
-    disableAutodelete:boolean,
-    /**(Default: `true`) Delete state on channel deletion. */
-    autodeleteOnChannelDelete:boolean,
-    /**(Default: `true`) Delete state on message deletion. */
-    autodeleteOnMessageDelete:boolean,
-    /**(Default: `true`) Delete state when the user leaves the guild/server. */
-    autodeleteOnUserLeave:boolean,
-    /**(Default: `false`) Delete state on bot restart. */
-    autodeleteOnRestart:boolean,
-    /**(Default: `true`) Delete state after 1 hour of an ephemeral message being sent. */
-    autodeleteOnEphemeral:boolean,
-    /**(Default: `null`) Delete state when unmodified/inactive for more than.... */
-    autodeleteAfterTimeout:null|{time:number,unit:"seconds"|"minutes"|"hours"|"days"},
-}
-
-/**## ODState `class`
- * An Open Discord state is a system for storing additional chunks of metadata for Discord messages.
- * A system for tracking messages or linking metadata, states or progress to Discord messages (ID-based).
- * 
- * Features automatic garbage collection to clear expired states. 
- */
-export class ODState<StateData extends any,WithGuildKey extends boolean,WithUserKey extends boolean> extends ODManagerData {
-    /**Alias to Open Discord message states database. */
-    protected database: ODDatabase<ODDatabaseIdConstraint>
-    /**Alias to Open Discord client manager. */
-    protected client: ODClientManager
-    /**Alias to Open Discord debugger. */
-    protected debug: ODDebugger|null = null
-    /**The settings of this state. */
-    settings: ODStateSettings
-    
-    constructor(id:ODValidId,client:ODClientManager,database:ODDatabase<ODDatabaseIdConstraint>,settings:Partial<ODStateSettings>){
-        super(id)
-        this.client = client
-        this.database = database
-        this.settings = {
-            disableAutodelete:false,
-            autodeleteOnChannelDelete:true,
-            autodeleteOnMessageDelete:true,
-            autodeleteOnUserLeave:true,
-            autodeleteOnRestart:false,
-            autodeleteOnEphemeral:true,
-            autodeleteAfterTimeout:null,
-            ...settings
-        }
-    }
-
-    /**Use the Open Discord debugger in this manager for logs. */
-    useDebug(debug?:ODDebugger|null){
-        this.debug = debug ?? null
-    }
-    /**Init the state and start autodeleting. The client must already be logged-in for this to work. */
-    async init(){
-        if (!this.client.loggedIn) throw new ODSystemError("ODState('"+this.id.value+"').init() => The client must be logged in for states to initialize.")
-
-        //autodelete on restart
-        if (!this.settings.disableAutodelete && this.settings.autodeleteOnRestart) this.clearAllMsgStates()
-
-        //autodelete on channelDelete
-        this.client.client.on("channelDelete",async (deletedChannel) => {
-            if (this.settings.disableAutodelete || !this.settings.autodeleteOnChannelDelete) return
-
-            for (const {key,value} of await this.listMsgStates()){
-                if (value.channelId === deletedChannel.id) await this.deleteMsgStateWithRawKey(key)
-            }
-        })
-        //autodelete on messageDelete
-        this.client.client.on("messageDelete",async (deletedMsg) => {
-            if (this.settings.disableAutodelete || !this.settings.autodeleteOnMessageDelete) return
-
-            for (const {key,value} of await this.listMsgStates()){
-                if (value.messageId === deletedMsg.id) await this.deleteMsgStateWithRawKey(key)
-            }
-        })
-        //autodelete on userLeave
-        this.client.client.on("guildMemberRemove",async (member) => {
-            if (this.settings.disableAutodelete || !this.settings.autodeleteOnUserLeave) return
-            if (member.guild.id !== this.client.mainServer?.id) return
-
-            for (const {key,value} of await this.listMsgStates()){
-                if (value.userId === member.id) await this.deleteMsgStateWithRawKey(key)
-            }
-        })
-
-        //autodelete when expired (ephemeral/timeout) every 30 seconds
-        this.purgeExpiredStates()
-        setInterval(() => {
-            this.purgeExpiredStates()
-        },30*1000)
-
-        //create a list of all channels, messages & users that still exist (and are part of states)
-        const existingChannelIds: string[] = []
-        const existingMessageIds: string[] = []
-        const existingUserIds: string[] = []
- 
-        for (const {key,value} of await this.listMsgStates()){
-            if (!existingChannelIds.includes(value.channelId)){
-                //check if channel still exists
-                const channel = await this.client.fetchChannel(value.channelId)
-                if (channel) existingChannelIds.push(channel.id)
-            }
-            if (!existingMessageIds.includes(value.messageId)){
-                //check if message still exists
-                const message = await this.client.fetchChannelMessage(value.channelId,value.messageId)
-                if (message) existingMessageIds.push(message.id)
-            }
-            if (value.userId && this.client.mainServer && !existingUserIds.includes(value.userId)){
-                //check if user still exists
-                const user = await this.client.fetchGuildMember(this.client.mainServer.id,value.userId)
-                if (user) existingUserIds.push(user.id)
-            }
-        }
-
-        //delete all states where a channel, message or user is missing (when the bot was offline)
-        for (const {key,value} of await this.listMsgStates()){
-            if (value.channelId && !existingChannelIds.includes(value.channelId)) await this.deleteMsgStateWithRawKey(key)
-            if (value.messageId && !existingMessageIds.includes(value.messageId)) await this.deleteMsgStateWithRawKey(key)
-            if (value.userId && !existingUserIds.includes(value.userId)) await this.deleteMsgStateWithRawKey(key)
-        }
-    }
-    /**Purge all expired message states that reached a timeout or ephemeral. */
-    protected async purgeExpiredStates(){
-        for (const {key,value} of await this.listMsgStates()){
-            if (value.deleteAfterDate && value.deleteAfterDate < Date.now()) await this.deleteMsgStateWithRawKey(key)
-        }
-    }
-    /**Transform the object-based message state key contents to a string. */
-    protected transformKey(key:ODStateKey<WithGuildKey,WithUserKey>){
-        const newGuild = (!("guild" in key) || !key.guild) ? "NULL" : (typeof key.guild === "string" ? key.guild : key.guild.id)
-        const newChannel = (!key.channel) ? "NULL" : (typeof key.channel === "string" ? key.channel : key.channel.id)
-        const newMessage = (!key.message) ? "NULL" : (typeof key.message === "string" ? key.message : key.message.id)
-        const newUser = (!("user" in key) || !key.user) ? "NULL" : (typeof key.user === "string" ? key.user : key.user.id)
-
-        return `G:${newGuild},C:${newChannel},M:${newMessage},U:${newUser}`
-    }
-    /**Transform the message state data contents for storage in the database. */
-    protected transformData(key:ODStateKey<WithGuildKey,WithUserKey>,data:StateData,isEphemeral:boolean,keepCreatedDate?:number): ODStateData<StateData> {
-        const guildId = (!("guild" in key) || !key.guild) ? null : (typeof key.guild === "string" ? key.guild : key.guild.id)
-        const channelId = (typeof key.channel === "string" ? key.channel : key.channel.id)
-        const messageId = (typeof key.message === "string" ? key.message : key.message.id)
-        const userId = (!("user" in key) || !key.user) ? null : (typeof key.user === "string" ? key.user : key.user.id)
-        const createdDate = keepCreatedDate ?? Date.now()
-        const modifiedDate = Date.now()
-
-        const unmodifiedTimeoutDate = this.timeoutToUnixTime()
-        const ephemeralTimeoutDate = (isEphemeral) ? Date.now()+(3600*1000) : null //delete ephemeral state after 1 hour
-        const deleteAfterDate = (unmodifiedTimeoutDate) ? unmodifiedTimeoutDate : ephemeralTimeoutDate
-
-        return {guildId,channelId,messageId,userId,createdDate,modifiedDate,deleteAfterDate,data}
-    }
-    /**Calculate milliseconds from a time + unit. */
-    protected timeoutToUnixTime(){
-        const timeout = this.settings.autodeleteAfterTimeout
-        if (!timeout) return null
-        if (timeout.unit == "seconds") return Date.now() + (timeout.time * 1000)
-        else if (timeout.unit == "minutes") return Date.now() + (timeout.time * 1000 * 60)
-        else if (timeout.unit == "hours") return Date.now() + (timeout.time * 1000 * 3600)
-        else if (timeout.unit == "days") return Date.now() + (timeout.time * 1000 * 3600 * 24)
-        else return null
-    }
-    /**Set a message state using guild, channel & message id as key. Returns `true` when overwritten. */
-    async setMsgState(key:ODStateKey<WithGuildKey,WithUserKey>,data:StateData,isEphemeral:boolean): Promise<boolean> {
-        const rawKey = this.transformKey(key)
-        
-        const existingData = await this.getMsgState(key)
-        const contents = this.transformData(key,data,isEphemeral,existingData?.createdDate)
-        return await this.database.set(this.id.value,rawKey,contents)
-    }
-    /**Get a message state using guild, channel & message id as key. */
-    async getMsgState(key:ODStateKey<WithGuildKey,WithUserKey>): Promise<ODStateData<StateData>|null> {
-        const rawKey = this.transformKey(key)
-        const rawData = await this.database.get(this.id.value,rawKey)
-        if (typeof rawData !== "object") return null
-        else return rawData as ODStateData<StateData>
-    }
-    /**Delete a message state using guild, channel & message id as key. Returns `true` when deleted. */
-    async deleteMsgState(key:ODStateKey<WithGuildKey,WithUserKey>): Promise<boolean> {
-        const rawKey = this.transformKey(key)
-        return await this.database.delete(this.id.value,rawKey)
-    }
-    /**List all message states of this `ODState`. */
-    async listMsgStates(): Promise<{key:string,value:ODStateData<StateData>}[]> {
-        return ((await this.database.getCategory(this.id.value)) ?? []) as {key:string,value:ODStateData<StateData>}[]
-    }
-    /**Delete all message states from this ODState. */
-    async clearAllMsgStates(): Promise<void> {
-        for (const state of await this.database.getAll()){
-            await this.database.delete(state.category,state.key)
-        }
-    }
-    /**Delete a message state using the raw key. Returns `true` when deleted. */
-    protected async deleteMsgStateWithRawKey(rawKey:string): Promise<boolean> {
-        return await this.database.delete(this.id.value,rawKey)
-    }
-}
-
-/**## ODStateManagerIdConstraint `type`
- * The constraint/layout for id mappings/interfaces of the `ODStateManager` class.
- */
-export type ODStateManagerIdConstraint = Record<string,ODState<any,boolean,boolean>>
-
-/**## ODStateManager `class`
- * The Open Discord state manager is a system for tracking messages or linking metadata, states or progress to Discord messages (ID-based).
- * 
- * Features automatic garbage collection to clear expired states. 
- */
-export class ODStateManager<IdList extends ODStateManagerIdConstraint = ODStateManagerIdConstraint> extends ODManager<ODState<any,boolean,boolean>> {
-    constructor(debug:ODDebugger){
-        super(debug,"state")
-    }
-
-    /**Init all states. */
-    async init(){
-        for (const state of this.getAll()){
-            await state.init()
-        }
-    }
-
-    add(data:ODState<any,boolean,boolean>, overwrite?:boolean): boolean {
-        data.useDebug(this.debug)
-        return super.add(data,overwrite)
-    }
-
-    get<StateId extends keyof ODNoGeneric<IdList>>(id:StateId): IdList[StateId]
-    get(id:ODValidId): ODState<any,boolean,boolean>|null
-    
-    get(id:ODValidId): ODState<any,boolean,boolean>|null {
-        return super.get(id)
-    }
-
-    remove<StateId extends keyof ODNoGeneric<IdList>>(id:StateId): IdList[StateId]
-    remove(id:ODValidId): ODState<any,boolean,boolean>|null
-    
-    remove(id:ODValidId): ODState<any,boolean,boolean>|null {
-        return super.remove(id)
-    }
-
-    exists(id:keyof ODNoGeneric<IdList>): boolean
-    exists(id:ODValidId): boolean
-    
-    exists(id:ODValidId): boolean {
-        return super.exists(id)
-    }
-}

package/src/api/modules/statistic.ts

@@ -1,380 +0,0 @@
-///////////////////////////////////////
-//STATISTIC MODULE
-///////////////////////////////////////
-import { ODId, ODManager, ODManagerData, ODNoGeneric, ODSystemError, ODValidId } from "./base.js"
-import { ODDebugger } from "./console.js"
-import { ODDatabase, ODDatabaseIdConstraint, ODJsonDatabaseStructure } from "./database.js"
-import * as discord from "discord.js"
-
-/**## ODValidStatisticValue `type`
- * These are the only allowed types for a statistic value to improve compatibility with different database systems.
- */
-export type ODValidStatisticValue = string|number|boolean
-
-/**## ODStatisticManagerInitCallback `type`
- * This callback can be used to execute something when the statistics have been initiated.
- * 
- * By default this is used to clear statistics from users that left the server or tickets which don't exist anymore.
- */
-export type ODStatisticManagerInitCallback = (database:ODJsonDatabaseStructure, deletables:ODJsonDatabaseStructure) => void|Promise<void>
-
-/**## ODStatisticScopeSetMode `type`
- * This type contains all valid methods for changing the value of a statistic.
- */
-export type ODStatisticScopeSetMode = "set"|"increase"|"decrease"
-
-/**## ODStatisticManagerIdConstraint `type`
- * The constraint/layout for id mappings/interfaces of the `ODStatisticManager` class.
- */
-export type ODStatisticManagerIdConstraint = Record<string,ODStatisticScope>
-
-/**## ODStatisticManager `class`
- * This is an Open Discord statistics manager.
- * 
- * This class is responsible for managing all statistics of the bot.
- * Statistic are categorized in "scopes" which can be accessed in this manager.
- * 
- * Statistic can be accessed in the individual scopes.
- */
-export class ODStatisticManager<IdList extends ODStatisticManagerIdConstraint = ODStatisticManagerIdConstraint> extends ODManager<ODStatisticScope> {
-    /**Alias to Open Discord statistics database. */
-    database: ODDatabase<ODDatabaseIdConstraint>|null = null
-    /**All the listeners for the init event. */
-    protected initListeners: ODStatisticManagerInitCallback[] = []
-
-    constructor(debug:ODDebugger){
-        super(debug,"statistic scope")
-    }
-
-    /**Select the database to use to read/write all statistics from/to. */
-    useDatabase(database:ODDatabase<ODDatabaseIdConstraint>){
-        this.database = database
-    }
-    add(data:ODStatisticScope, overwrite?:boolean): boolean {
-        data.useDebug(this.debug,"stat")
-        if (this.database) data.useDatabase(this.database)
-        return super.add(data,overwrite)
-    }
-    /**Init all statistics and run `onInit()` listeners. */
-    async init(){
-        if (!this.database) throw new ODSystemError("Unable to initialize statistics 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 statistics
-        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 statistics
-        for (const data of deletableStats){
-            if (!this.database) return
-            await this.database.delete(data.category,data.key)
-        }
-    }
-    /**Reset all statistics. (clears the entire database) */
-    async reset(){
-        if (!this.database) return
-        const data = await this.database.getAll()
-        for (const d of data){
-            await this.database.delete(d.category,d.key)
-        }
-    }
-    /**Run a function when the statistics are initialized. This can be used to clear statistics from users that left the server or tickets which don't exist anymore. */
-    onInit(callback:ODStatisticManagerInitCallback){
-        this.initListeners.push(callback)
-    }
-
-    get<ScopeId extends keyof ODNoGeneric<IdList>>(id:ScopeId): IdList[ScopeId]
-    get(id:ODValidId): ODStatisticScope|null
-    
-    get(id:ODValidId): ODStatisticScope|null {
-        return super.get(id)
-    }
-
-    remove<ScopeId extends keyof ODNoGeneric<IdList>>(id:ScopeId): IdList[ScopeId]
-    remove(id:ODValidId): ODStatisticScope|null
-    
-    remove(id:ODValidId): ODStatisticScope|null {
-        return super.remove(id)
-    }
-
-    exists(id:keyof ODNoGeneric<IdList>): boolean
-    exists(id:ODValidId): boolean
-    
-    exists(id:ODValidId): boolean {
-        return super.exists(id)
-    }
-}
-/**## ODStatisticScopeIdConstraint `type`
- * The constraint/layout for id mappings/interfaces of the `ODStatisticScope` class.
- */
-export type ODStatisticScopeIdConstraint = Record<string,ODStatistic>
-
-/**## ODStatisticScope `class`
- * This is an Open Discord statistic scope.
- * 
- * A scope can contain multiple statistics. Every scope is seperated from other scopes.
- * Here, you can read & write the values of all statistics.
- * 
- * The built-in Open Discord scopes are: `global`, `user`, `ticket`
- */
-export class ODStatisticScope<IdList extends ODStatisticScopeIdConstraint = ODStatisticScopeIdConstraint> extends ODManager<ODStatistic> {
-    /**The id of this statistics scope. */
-    id: ODId
-    /**Is this scope already initialized? */
-    ready: boolean = false
-    /**Alias to Open Discord statistics database. */
-    database: ODDatabase<ODDatabaseIdConstraint>|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 statistics from/to. (Automatically assigned when used in `ODStatisticManager`) */
-    useDatabase(database:ODDatabase<ODDatabaseIdConstraint>){
-        this.database = database
-    }
-    /**Get the value of a statistic. The `scopeId` is the unique id of the user, channel, role, etc that the statistics are related to. */
-    getStat<StatisticId extends keyof ODNoGeneric<IdList>>(id:StatisticId, scopeId:string): Promise<ODValidStatisticValue|null>
-    getStat(id:ODValidId, scopeId:string): Promise<ODValidStatisticValue|null>
-    async getStat(id:ODValidId, scopeId:string): Promise<ODValidStatisticValue|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 statistics 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 statistics are related to. */
-    getAllStats<StatisticId extends keyof ODNoGeneric<IdList>>(id:StatisticId): Promise<{id:string,value:ODValidStatisticValue}[]>
-    getAllStats(id:ODValidId): Promise<{id:string,value:ODValidStatisticValue}[]>
-    async getAllStats(id:ODValidId): Promise<{id:string,value:ODValidStatisticValue}[]> {
-        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:ODValidStatisticValue}[] = []
-
-        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 statistics are related to. */
-    setStat<StatisticId extends keyof ODNoGeneric<IdList>>(id:StatisticId, scopeId:string, value:ODValidStatisticValue, mode:ODStatisticScopeSetMode): Promise<boolean>
-    setStat(id:ODValidId, scopeId:string, value:ODValidStatisticValue, mode:ODStatisticScopeSetMode): Promise<boolean>
-    async setStat(id:ODValidId, scopeId:string, value:ODValidStatisticValue, mode:ODStatisticScopeSetMode): 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 statistics are related to. */
-    resetStat<StatisticId extends keyof ODNoGeneric<IdList>>(id:ODValidId, scopeId:string): Promise<ODValidStatisticValue|null>
-    resetStat(id:ODValidId, scopeId:string): Promise<ODValidStatisticValue|null>
-    async resetStat(id:ODValidId, scopeId:string): Promise<ODValidStatisticValue|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 statistic scope & return a list of all statistic ids in the following format: `<scopeid>_<statid>`  */
-    init(): string[] {
-        //get all valid statistics categories
-        this.ready = true
-        return this.getAll().map((stat) => this.id.value+"_"+stat.id.value)
-    }
-    /**Render all statistics 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 ODDynamicStatistic){
-                    //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")
-    }
-
-    get<StatisticId extends keyof ODNoGeneric<IdList>>(id:StatisticId): IdList[StatisticId]
-    get(id:ODValidId): ODStatistic|null
-    
-    get(id:ODValidId): ODStatistic|null {
-        return super.get(id)
-    }
-
-    remove<StatisticId extends keyof ODNoGeneric<IdList>>(id:StatisticId): IdList[StatisticId]
-    remove(id:ODValidId): ODStatistic|null
-    
-    remove(id:ODValidId): ODStatistic|null {
-        return super.remove(id)
-    }
-
-    exists(id:keyof ODNoGeneric<IdList>): boolean
-    exists(id:ODValidId): boolean
-    
-    exists(id:ODValidId): boolean {
-        return super.exists(id)
-    }
-}
-
-/**## ODStatisticGlobalScope `class`
- * This is an Open Discord statistic global scope.
- * 
- * A scope can contain multiple statistics. Every scope is seperated from other scopes.
- * Here, you can read & write the values of all statistics.
- * 
- * This scope is made specifically for the global statistics of Open Discord.
- */
-export class ODStatisticGlobalScope<IdList extends ODStatisticScopeIdConstraint = ODStatisticScopeIdConstraint> extends ODStatisticScope<IdList> {
-    getStat<StatisticId extends keyof ODNoGeneric<IdList>>(id:StatisticId): Promise<ODValidStatisticValue|null>
-    getStat(id:ODValidId): Promise<ODValidStatisticValue|null>
-    getStat(id:ODValidId): Promise<ODValidStatisticValue|null> {
-        return super.getStat(id,"GLOBAL")
-    }
-
-    getAllStats<StatisticId extends keyof ODNoGeneric<IdList>>(id:StatisticId): Promise<{id:string,value:ODValidStatisticValue}[]>
-    getAllStats(id:ODValidId): Promise<{id:string,value:ODValidStatisticValue}[]>
-    getAllStats(id:ODValidId): Promise<{id:string,value:ODValidStatisticValue}[]> {
-        return super.getAllStats(id)
-    }
-
-    setStat<StatisticId extends keyof ODNoGeneric<IdList>>(id:StatisticId, value:ODValidStatisticValue, mode:ODStatisticScopeSetMode): Promise<boolean>
-    setStat(id:ODValidId, value:ODValidStatisticValue, mode:ODStatisticScopeSetMode): Promise<boolean>
-    setStat(id:ODValidId, value:ODValidStatisticValue, mode:ODStatisticScopeSetMode): Promise<boolean> {
-        return super.setStat(id,"GLOBAL",value,mode)
-    }
-
-    resetStat<StatisticId extends keyof ODNoGeneric<IdList>>(id:ODValidId): Promise<ODValidStatisticValue|null>
-    resetStat(id:ODValidId): Promise<ODValidStatisticValue|null>
-    resetStat(id:ODValidId): Promise<ODValidStatisticValue|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)
-    }
-}
-
-/**## ODStatisticRenderer `type`
- * This callback will render a single statistic for a discord embed/message.
- */
-export type ODStatisticRenderer = (value:ODValidStatisticValue, scopeId:string, guild:discord.Guild, channel:discord.TextBasedChannel, user:discord.User) => string|Promise<string>
-
-/**## ODStatistic `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 statistics scope to register a new statistic. A statistic can also include a priority to choose the render priority.
- * 
- * It's recommended to use the `ODBaseStatistic` & `ODDynamicStatistic` classes instead of this one!
- */
-export class ODStatistic extends ODManagerData {
-    /**The priority of this statistic. */
-    priority: number
-    /**The render function of this statistic. */
-    render: ODStatisticRenderer
-    /**The value of this statistic. */
-    value: ODValidStatisticValue|null
-
-    constructor(id:ODValidId, priority:number, render:ODStatisticRenderer, value?:ODValidStatisticValue){
-        super(id)
-        this.priority = priority
-        this.render = render
-        this.value = value ?? null
-    }
-}
-
-/**## ODBaseStatistic `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 statistics scope.
- */
-export class ODBaseStatistic extends ODStatistic {
-    /**The name of this statistic. Rendered in discord embeds/messages. */
-    name: string
-
-    constructor(id:ODValidId, priority:number, name:string, value:ODValidStatisticValue){
-        super(id,priority,(value) => {
-            return ""+name+": `"+value.toString()+"`"
-        },value)
-        this.name = name
-    }
-}
-
-/**## ODDynamicStatisticRenderer `type`
- * This callback will render a single dynamic statistic for a discord embed/message.
- */
-export type ODDynamicStatisticRenderer = (scopeId:string, guild:discord.Guild, channel:discord.TextBasedChannel, user:discord.User) => string|Promise<string>
-
-/**## ODDynamicStatistic `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 ODDynamicStatistic extends ODStatistic {
-    constructor(id:ODValidId, priority:number, render:ODDynamicStatisticRenderer){
-        super(id,priority,(value,scopeId,guild,channel,user) => {
-            return render(scopeId,guild,channel,user)
-        })
-    }
-}