@open-discord-bots/framework 0.0.1 → 0.0.2

package/dist/api/modules/cooldown.d.ts

@@ -0,0 +1,138 @@
+import { ODValidId, ODManager, ODManagerData } from "./base";
+import { ODDebugger } from "./console";
+/**## ODCooldownManager `class`
+ * This is an Open Discord cooldown manager.
+ *
+ * It is responsible for managing all cooldowns in Open Discord. An example of this is the ticket creation cooldown.
+ *
+ * There are many types of cooldowns available, but you can also create your own!
+ */
+export declare class ODCooldownManager extends ODManager<ODCooldown<object>> {
+    constructor(debug: ODDebugger);
+    /**Initiate all cooldowns in this manager. */
+    init(): Promise<void>;
+}
+/**## ODCooldownData `class`
+ * This is Open Discord cooldown data.
+ *
+ * It contains the instance of an active cooldown (e.g. for a user). It is handled by the cooldown itself.
+ */
+export declare class ODCooldownData<Data extends object> extends ODManagerData {
+    /**Is this cooldown active? */
+    active: boolean;
+    /**Additional data of this cooldown instance. (different for each cooldown type) */
+    data: Data;
+    constructor(id: ODValidId, active: boolean, data: Data);
+}
+/**## ODCooldown `class`
+ * This is an Open Discord cooldown.
+ *
+ * It doesn't do anything on it's own, but it provides the methods that are used to interact with a cooldown.
+ * This class can be extended from to create a working cooldown.
+ *
+ * There are also premade cooldowns available in the bot!
+ */
+export declare class ODCooldown<Data extends object> extends ODManagerData {
+    data: ODManager<ODCooldownData<Data>>;
+    /**Is this cooldown already initialized? */
+    ready: boolean;
+    constructor(id: ODValidId);
+    /**Check this id and start cooldown when it exeeds the limit! Returns `true` when on cooldown! */
+    use(id: string): boolean;
+    /**Check this id without starting or updating the cooldown. Returns `true` when on cooldown! */
+    check(id: string): boolean;
+    /**Remove the cooldown for an id when available.*/
+    delete(id: string): void;
+    /**Initialize the internal systems of this cooldown. */
+    init(): Promise<void>;
+}
+/**## ODCounterCooldown `class`
+ * This is an Open Discord counter cooldown.
+ *
+ * It is is a cooldown based on a counter. When the number exceeds the limit, the cooldown is activated.
+ * The number will automatically be decreased with a set amount & interval.
+ */
+export declare class ODCounterCooldown extends ODCooldown<{
+    value: number;
+}> {
+    /**The cooldown will activate when exceeding this limit. */
+    activeLimit: number;
+    /**The cooldown will deactivate when below this limit. */
+    cancelLimit: number;
+    /**The amount to increase the counter with everytime the cooldown is triggered/updated. */
+    increment: number;
+    /**The amount to decrease the counter over time. */
+    decrement: number;
+    /**The interval between decrements in milliseconds. */
+    invervalMs: number;
+    constructor(id: ODValidId, activeLimit: number, cancelLimit: number, increment: number, decrement: number, intervalMs: number);
+    use(id: string): boolean;
+    check(id: string): boolean;
+    delete(id: string): void;
+    init(): Promise<void>;
+}
+/**## ODIncrementalCounterCooldown `class`
+ * This is an Open Discord incremental counter cooldown.
+ *
+ * It is is a cooldown based on an incremental counter. It is exactly the same as the normal counter,
+ * with the only difference being that it still increments when the limit is already exeeded.
+ */
+export declare class ODIncrementalCounterCooldown extends ODCooldown<{
+    value: number;
+}> {
+    /**The cooldown will activate when exceeding this limit. */
+    activeLimit: number;
+    /**The cooldown will deactivate when below this limit. */
+    cancelLimit: number;
+    /**The amount to increase the counter with everytime the cooldown is triggered/updated. */
+    increment: number;
+    /**The amount to decrease the counter over time. */
+    decrement: number;
+    /**The interval between decrements in milliseconds. */
+    invervalMs: number;
+    constructor(id: ODValidId, activeLimit: number, cancelLimit: number, increment: number, decrement: number, intervalMs: number);
+    use(id: string): boolean;
+    check(id: string): boolean;
+    delete(id: string): void;
+    init(): Promise<void>;
+}
+/**## ODTimeoutCooldown `class`
+ * This is an Open Discord timeout cooldown.
+ *
+ * It is a cooldown based on a timer. When triggered/updated, the cooldown is activated for the set amount of time.
+ * After the timer has timed out, the cooldown will be deleted.
+ */
+export declare class ODTimeoutCooldown extends ODCooldown<{
+    date: number;
+}> {
+    /**The amount of milliseconds before the cooldown times-out */
+    timeoutMs: number;
+    constructor(id: ODValidId, timeoutMs: number);
+    use(id: string): boolean;
+    check(id: string): boolean;
+    delete(id: string): void;
+    /**Get the remaining amount of milliseconds before the timeout stops. */
+    remaining(id: string): number | null;
+    init(): Promise<void>;
+}
+/**## ODIncrementalTimeoutCooldown `class`
+ * This is an Open Discord incremental timeout cooldown.
+ *
+ * It is is a cooldown based on an incremental timer. It is exactly the same as the normal timer,
+ * with the only difference being that it adds additional time when triggered/updated while the cooldown is already active.
+ */
+export declare class ODIncrementalTimeoutCooldown extends ODCooldown<{
+    date: number;
+}> {
+    /**The amount of milliseconds before the cooldown times-out */
+    timeoutMs: number;
+    /**The amount of milliseconds to add when triggered/updated while the cooldown is already active. */
+    incrementMs: number;
+    constructor(id: ODValidId, timeoutMs: number, incrementMs: number);
+    use(id: string): boolean;
+    check(id: string): boolean;
+    delete(id: string): void;
+    /**Get the remaining amount of milliseconds before the timeout stops. */
+    remaining(id: string): number | null;
+    init(): Promise<void>;
+}

package/dist/api/modules/cooldown.js

@@ -0,0 +1,359 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ODIncrementalTimeoutCooldown = exports.ODTimeoutCooldown = exports.ODIncrementalCounterCooldown = exports.ODCounterCooldown = exports.ODCooldown = exports.ODCooldownData = exports.ODCooldownManager = void 0;
+///////////////////////////////////////
+//COOLDOWN MODULE
+///////////////////////////////////////
+const base_1 = require("./base");
+/**## ODCooldownManager `class`
+ * This is an Open Discord cooldown manager.
+ *
+ * It is responsible for managing all cooldowns in Open Discord. An example of this is the ticket creation cooldown.
+ *
+ * There are many types of cooldowns available, but you can also create your own!
+ */
+class ODCooldownManager extends base_1.ODManager {
+    constructor(debug) {
+        super(debug, "cooldown");
+    }
+    /**Initiate all cooldowns in this manager. */
+    async init() {
+        for (const cooldown of this.getAll()) {
+            await cooldown.init();
+        }
+    }
+}
+exports.ODCooldownManager = ODCooldownManager;
+/**## ODCooldownData `class`
+ * This is Open Discord cooldown data.
+ *
+ * It contains the instance of an active cooldown (e.g. for a user). It is handled by the cooldown itself.
+ */
+class ODCooldownData extends base_1.ODManagerData {
+    /**Is this cooldown active? */
+    active;
+    /**Additional data of this cooldown instance. (different for each cooldown type) */
+    data;
+    constructor(id, active, data) {
+        super(id);
+        this.active = active;
+        this.data = data;
+    }
+}
+exports.ODCooldownData = ODCooldownData;
+/**## ODCooldown `class`
+ * This is an Open Discord cooldown.
+ *
+ * It doesn't do anything on it's own, but it provides the methods that are used to interact with a cooldown.
+ * This class can be extended from to create a working cooldown.
+ *
+ * There are also premade cooldowns available in the bot!
+ */
+class ODCooldown extends base_1.ODManagerData {
+    data = new base_1.ODManager();
+    /**Is this cooldown already initialized? */
+    ready = false;
+    constructor(id) {
+        super(id);
+    }
+    /**Check this id and start cooldown when it exeeds the limit! Returns `true` when on cooldown! */
+    use(id) {
+        throw new base_1.ODSystemError("Tried to use an unimplemented ODCooldown!");
+    }
+    /**Check this id without starting or updating the cooldown. Returns `true` when on cooldown! */
+    check(id) {
+        throw new base_1.ODSystemError("Tried to use an unimplemented ODCooldown!");
+    }
+    /**Remove the cooldown for an id when available.*/
+    delete(id) {
+        throw new base_1.ODSystemError("Tried to use an unimplemented ODCooldown!");
+    }
+    /**Initialize the internal systems of this cooldown. */
+    async init() {
+        throw new base_1.ODSystemError("Tried to use an unimplemented ODCooldown!");
+    }
+}
+exports.ODCooldown = ODCooldown;
+/**## ODCounterCooldown `class`
+ * This is an Open Discord counter cooldown.
+ *
+ * It is is a cooldown based on a counter. When the number exceeds the limit, the cooldown is activated.
+ * The number will automatically be decreased with a set amount & interval.
+ */
+class ODCounterCooldown extends ODCooldown {
+    /**The cooldown will activate when exceeding this limit. */
+    activeLimit;
+    /**The cooldown will deactivate when below this limit. */
+    cancelLimit;
+    /**The amount to increase the counter with everytime the cooldown is triggered/updated. */
+    increment;
+    /**The amount to decrease the counter over time. */
+    decrement;
+    /**The interval between decrements in milliseconds. */
+    invervalMs;
+    constructor(id, activeLimit, cancelLimit, increment, decrement, intervalMs) {
+        super(id);
+        this.activeLimit = activeLimit;
+        this.cancelLimit = cancelLimit;
+        this.increment = increment;
+        this.decrement = decrement;
+        this.invervalMs = intervalMs;
+    }
+    use(id) {
+        const cooldown = this.data.get(id);
+        if (cooldown) {
+            //cooldown for this id already exists
+            if (cooldown.active) {
+                return true;
+            }
+            else if (cooldown.data.value < this.activeLimit) {
+                cooldown.data.value = cooldown.data.value + this.increment;
+                return false;
+            }
+            else {
+                cooldown.active = true;
+                return false;
+            }
+        }
+        else {
+            //cooldown for this id doesn't exist
+            this.data.add(new ODCooldownData(id, (this.increment >= this.activeLimit), {
+                value: this.increment
+            }));
+            return false;
+        }
+    }
+    check(id) {
+        const cooldown = this.data.get(id);
+        if (cooldown) {
+            //cooldown for this id already exists
+            return cooldown.active;
+        }
+        else
+            return false;
+    }
+    delete(id) {
+        this.data.remove(id);
+    }
+    async init() {
+        if (this.ready)
+            return;
+        setInterval(async () => {
+            await this.data.loopAll((cooldown) => {
+                cooldown.data.value = cooldown.data.value - this.decrement;
+                if (cooldown.data.value <= this.cancelLimit) {
+                    cooldown.active = false;
+                }
+                if (cooldown.data.value <= 0) {
+                    this.data.remove(cooldown.id);
+                }
+            });
+        }, this.invervalMs);
+        this.ready = true;
+    }
+}
+exports.ODCounterCooldown = ODCounterCooldown;
+/**## ODIncrementalCounterCooldown `class`
+ * This is an Open Discord incremental counter cooldown.
+ *
+ * It is is a cooldown based on an incremental counter. It is exactly the same as the normal counter,
+ * with the only difference being that it still increments when the limit is already exeeded.
+ */
+class ODIncrementalCounterCooldown extends ODCooldown {
+    /**The cooldown will activate when exceeding this limit. */
+    activeLimit;
+    /**The cooldown will deactivate when below this limit. */
+    cancelLimit;
+    /**The amount to increase the counter with everytime the cooldown is triggered/updated. */
+    increment;
+    /**The amount to decrease the counter over time. */
+    decrement;
+    /**The interval between decrements in milliseconds. */
+    invervalMs;
+    constructor(id, activeLimit, cancelLimit, increment, decrement, intervalMs) {
+        super(id);
+        this.activeLimit = activeLimit;
+        this.cancelLimit = cancelLimit;
+        this.increment = increment;
+        this.decrement = decrement;
+        this.invervalMs = intervalMs;
+    }
+    use(id) {
+        const cooldown = this.data.get(id);
+        if (cooldown) {
+            //cooldown for this id already exists
+            if (cooldown.active) {
+                cooldown.data.value = cooldown.data.value + this.increment;
+                return true;
+            }
+            else if (cooldown.data.value < this.activeLimit) {
+                cooldown.data.value = cooldown.data.value + this.increment;
+                return false;
+            }
+            else {
+                cooldown.active = true;
+                return false;
+            }
+        }
+        else {
+            //cooldown for this id doesn't exist
+            this.data.add(new ODCooldownData(id, (this.increment >= this.activeLimit), {
+                value: this.increment
+            }));
+            return false;
+        }
+    }
+    check(id) {
+        const cooldown = this.data.get(id);
+        if (cooldown) {
+            //cooldown for this id already exists
+            return cooldown.active;
+        }
+        else
+            return false;
+    }
+    delete(id) {
+        this.data.remove(id);
+    }
+    async init() {
+        if (this.ready)
+            return;
+        setInterval(async () => {
+            await this.data.loopAll((cooldown) => {
+                cooldown.data.value = cooldown.data.value - this.decrement;
+                if (cooldown.data.value <= this.cancelLimit) {
+                    cooldown.active = false;
+                }
+                if (cooldown.data.value <= 0) {
+                    this.data.remove(cooldown.id);
+                }
+            });
+        }, this.invervalMs);
+        this.ready = true;
+    }
+}
+exports.ODIncrementalCounterCooldown = ODIncrementalCounterCooldown;
+/**## ODTimeoutCooldown `class`
+ * This is an Open Discord timeout cooldown.
+ *
+ * It is a cooldown based on a timer. When triggered/updated, the cooldown is activated for the set amount of time.
+ * After the timer has timed out, the cooldown will be deleted.
+ */
+class ODTimeoutCooldown extends ODCooldown {
+    /**The amount of milliseconds before the cooldown times-out */
+    timeoutMs;
+    constructor(id, timeoutMs) {
+        super(id);
+        this.timeoutMs = timeoutMs;
+    }
+    use(id) {
+        const cooldown = this.data.get(id);
+        if (cooldown) {
+            //cooldown for this id already exists
+            if ((new Date().getTime() - cooldown.data.date) > this.timeoutMs) {
+                this.data.remove(id);
+                return false;
+            }
+            else {
+                return true;
+            }
+        }
+        else {
+            //cooldown for this id doesn't exist
+            this.data.add(new ODCooldownData(id, true, {
+                date: new Date().getTime()
+            }));
+            return false;
+        }
+    }
+    check(id) {
+        const cooldown = this.data.get(id);
+        if (cooldown) {
+            //cooldown for this id already exists
+            return true;
+        }
+        else
+            return false;
+    }
+    delete(id) {
+        this.data.remove(id);
+    }
+    /**Get the remaining amount of milliseconds before the timeout stops. */
+    remaining(id) {
+        const cooldown = this.data.get(id);
+        if (!cooldown)
+            return null;
+        const rawResult = this.timeoutMs - (new Date().getTime() - cooldown.data.date);
+        return (rawResult > 0) ? rawResult : 0;
+    }
+    async init() {
+        if (this.ready)
+            return;
+        this.ready = true;
+    }
+}
+exports.ODTimeoutCooldown = ODTimeoutCooldown;
+/**## ODIncrementalTimeoutCooldown `class`
+ * This is an Open Discord incremental timeout cooldown.
+ *
+ * It is is a cooldown based on an incremental timer. It is exactly the same as the normal timer,
+ * with the only difference being that it adds additional time when triggered/updated while the cooldown is already active.
+ */
+class ODIncrementalTimeoutCooldown extends ODCooldown {
+    /**The amount of milliseconds before the cooldown times-out */
+    timeoutMs;
+    /**The amount of milliseconds to add when triggered/updated while the cooldown is already active. */
+    incrementMs;
+    constructor(id, timeoutMs, incrementMs) {
+        super(id);
+        this.timeoutMs = timeoutMs;
+        this.incrementMs = incrementMs;
+    }
+    use(id) {
+        const cooldown = this.data.get(id);
+        if (cooldown) {
+            //cooldown for this id already exists
+            if ((new Date().getTime() - cooldown.data.date) > this.timeoutMs) {
+                this.data.remove(id);
+                return false;
+            }
+            else {
+                cooldown.data.date = cooldown.data.date + this.incrementMs;
+                return true;
+            }
+        }
+        else {
+            //cooldown for this id doesn't exist
+            this.data.add(new ODCooldownData(id, true, {
+                date: new Date().getTime()
+            }));
+            return false;
+        }
+    }
+    check(id) {
+        const cooldown = this.data.get(id);
+        if (cooldown) {
+            //cooldown for this id already exists
+            return true;
+        }
+        else
+            return false;
+    }
+    delete(id) {
+        this.data.remove(id);
+    }
+    /**Get the remaining amount of milliseconds before the timeout stops. */
+    remaining(id) {
+        const cooldown = this.data.get(id);
+        if (!cooldown)
+            return null;
+        const rawResult = this.timeoutMs - (new Date().getTime() - cooldown.data.date);
+        return (rawResult > 0) ? rawResult : 0;
+    }
+    async init() {
+        if (this.ready)
+            return;
+        this.ready = true;
+    }
+}
+exports.ODIncrementalTimeoutCooldown = ODIncrementalTimeoutCooldown;

package/dist/api/modules/database.d.ts

@@ -0,0 +1,135 @@
+import { ODManager, ODManagerData, ODOptionalPromise, ODPromiseVoid, ODValidId, ODValidJsonType } from "./base";
+import { ODDebugger } from "./console";
+import * as fjs from "formatted-json-stringify";
+/**## ODDatabaseManager `class`
+ * This is an Open Discord database manager.
+ *
+ * It manages all databases in the bot and allows to permanently store data from the bot!
+ *
+ * You can use this class to get/add a database (`ODDatabase`) in your plugin!
+ */
+export declare class ODDatabaseManager extends ODManager<ODDatabase> {
+    constructor(debug: ODDebugger);
+    /**Init all database files. */
+    init(): Promise<void>;
+}
+/**## ODDatabase `class`
+ * This is an Open Discord database template.
+ * This class doesn't do anything at all, it just gives a template & basic methods for a database. Use `ODJsonDatabase` instead!
+ *
+ * You can use this class if you want to create your own database implementation (e.g. `mongodb`, `mysql`,...)!
+ */
+export declare class ODDatabase extends ODManagerData {
+    /**The name of the file with extension. */
+    file: string;
+    /**The path to the file relative to the main directory. */
+    path: string;
+    /**Init the database. */
+    init(): ODPromiseVoid;
+    /**Add/Overwrite a specific category & key in the database. Returns `true` when overwritten. */
+    set(category: string, key: string, value: ODValidJsonType): ODOptionalPromise<boolean>;
+    /**Get a specific category & key in the database */
+    get(category: string, key: string): ODOptionalPromise<ODValidJsonType | undefined>;
+    /**Delete a specific category & key in the database */
+    delete(category: string, key: string): ODOptionalPromise<boolean>;
+    /**Check if a specific category & key exists in the database */
+    exists(category: string, key: string): ODOptionalPromise<boolean>;
+    /**Get a specific category in the database */
+    getCategory(category: string): ODOptionalPromise<{
+        key: string;
+        value: ODValidJsonType;
+    }[] | undefined>;
+    /**Get all values in the database */
+    getAll(): ODOptionalPromise<ODJsonDatabaseStructure>;
+}
+/**## ODJsonDatabaseStructure `type`
+ * This is the structure of how a JSON database file!
+ */
+export type ODJsonDatabaseStructure = {
+    category: string;
+    key: string;
+    value: ODValidJsonType;
+}[];
+/**## ODJsonDatabase `class`
+ * This is an Open Discord JSON database.
+ * It stores data in a `json` file as a large `Array` using the `category`, `key`, `value` strategy.
+ * You can store the following types: `string`, `number`, `boolean`, `array`, `object` & `null`!
+ *
+ * You can use this class if you want to add your own database or to use an existing one!
+ */
+export declare class ODJsonDatabase extends ODDatabase {
+    #private;
+    constructor(id: ODValidId, file: string, customPath?: string);
+    /**Init the database. */
+    init(): ODPromiseVoid;
+    /**Set/overwrite the value of `category` & `key`. Returns `true` when overwritten!
+     * @example
+     * const didOverwrite = database.setData("category","key","value") //value can be any of the valid types
+     * //You need an ODJsonDatabase class named "database" for this example to work!
+     */
+    set(category: string, key: string, value: ODValidJsonType): ODOptionalPromise<boolean>;
+    /**Get the value of `category` & `key`. Returns `undefined` when non-existent!
+     * @example
+     * const data = database.getData("category","key") //data will be the value
+     * //You need an ODJsonDatabase class named "database" for this example to work!
+     */
+    get(category: string, key: string): ODOptionalPromise<ODValidJsonType | undefined>;
+    /**Remove the value of `category` & `key`. Returns `undefined` when non-existent!
+     * @example
+     * const didExist = database.deleteData("category","key") //delete this value
+     * //You need an ODJsonDatabase class named "database" for this example to work!
+     */
+    delete(category: string, key: string): ODOptionalPromise<boolean>;
+    /**Check if a value of `category` & `key` exists. Returns `false` when non-existent! */
+    exists(category: string, key: string): ODOptionalPromise<boolean>;
+    /**Get all values in `category`. Returns `undefined` when non-existent! */
+    getCategory(category: string): ODOptionalPromise<{
+        key: string;
+        value: ODValidJsonType;
+    }[] | undefined>;
+    /**Get all values in `category`. */
+    getAll(): ODOptionalPromise<ODJsonDatabaseStructure>;
+}
+/**## ODFormattedJsonDatabase `class`
+ * This is an Open Discord Formatted JSON database.
+ * It stores data in a `json` file as a large `Array` using the `category`, `key`, `value` strategy.
+ * You can store the following types: `string`, `number`, `boolean`, `array`, `object` & `null`!
+ *
+ * This one is exactly the same as `ODJsonDatabase`, but it has a formatter from the `formatted-json-stringify` package.
+ * This can help you organise it a little bit better!
+ */
+export declare class ODFormattedJsonDatabase extends ODDatabase {
+    #private;
+    /**The formatter to use on the database array */
+    formatter: fjs.ArrayFormatter;
+    constructor(id: ODValidId, file: string, formatter: fjs.ArrayFormatter, customPath?: string);
+    /**Init the database. */
+    init(): ODPromiseVoid;
+    /**Set/overwrite the value of `category` & `key`. Returns `true` when overwritten!
+     * @example
+     * const didOverwrite = database.setData("category","key","value") //value can be any of the valid types
+     * //You need an ODFormattedJsonDatabase class named "database" for this example to work!
+     */
+    set(category: string, key: string, value: ODValidJsonType): ODOptionalPromise<boolean>;
+    /**Get the value of `category` & `key`. Returns `undefined` when non-existent!
+     * @example
+     * const data = database.getData("category","key") //data will be the value
+     * //You need an ODFormattedJsonDatabase class named "database" for this example to work!
+     */
+    get(category: string, key: string): ODOptionalPromise<ODValidJsonType | undefined>;
+    /**Remove the value of `category` & `key`. Returns `undefined` when non-existent!
+     * @example
+     * const didExist = database.deleteData("category","key") //delete this value
+     * //You need an ODFormattedJsonDatabase class named "database" for this example to work!
+     */
+    delete(category: string, key: string): ODOptionalPromise<boolean>;
+    /**Check if a value of `category` & `key` exists. Returns `false` when non-existent! */
+    exists(category: string, key: string): ODOptionalPromise<boolean>;
+    /**Get all values in `category`. Returns `undefined` when non-existent! */
+    getCategory(category: string): ODOptionalPromise<{
+        key: string;
+        value: ODValidJsonType;
+    }[] | undefined>;
+    /**Get all values in `category`. */
+    getAll(): ODOptionalPromise<ODJsonDatabaseStructure>;
+}