@mostfeatured/dbi 0.0.53 → 0.0.55

package/dist/Events.d.ts

@@ -1,54 +1,54 @@
-import { NamespaceEnums, NamespaceData } from "../generated/namespaceData";
-import { DBI } from "./DBI";
-import { ClientEvents } from "./types/Event";
-import { IDBIBaseExecuteCtx, TDBIRateLimitTypes } from "./types/Interaction";
-import { DBILocale } from "./types/Locale";
-export declare type TDBIEventNames = "beforeInteraction" | "afterInteraction" | "interactionRateLimit" | "beforeEvent" | "afterEvent" | "interactionError" | "eventError";
-export declare class Events<TNamespace extends NamespaceEnums> {
-    DBI: DBI<TNamespace>;
-    handlers: Record<string, Array<(data: any) => boolean | Promise<boolean>>>;
-    constructor(DBI: DBI<TNamespace>);
-    trigger(name: TDBIEventNames, data: any): Promise<boolean>;
-    on(eventName: "beforeInteraction" | "afterInteraction", handler: (data: IDBIBaseExecuteCtx<TNamespace>) => Promise<boolean> | boolean, options?: {
-        once: boolean;
-    }): (() => any);
-    on(eventName: "interactionError", handler: (data: IDBIBaseExecuteCtx<TNamespace> & {
-        error: any;
-    }) => Promise<boolean> | boolean, options?: {
-        once: boolean;
-    }): (() => any);
-    on(eventName: "beforeEvent" | "afterEvent", handler: (data: {
-        [K in keyof (ClientEvents & NamespaceData[TNamespace]["customEvents"])]: {
-            other: Record<string, any>;
-            locale?: {
-                guild: DBILocale<TNamespace>;
-            };
-            eventName: K;
-        } & (ClientEvents & NamespaceData[TNamespace]["customEvents"])[K];
-    }[keyof (ClientEvents & NamespaceData[TNamespace]["customEvents"])]) => Promise<boolean> | boolean, options?: {
-        once: boolean;
-    }): (() => any);
-    on(eventName: "eventError", handler: (data: {
-        [K in keyof (ClientEvents & NamespaceData[TNamespace]["customEvents"])]: {
-            other: Record<string, any>;
-            locale?: {
-                guild: DBILocale<TNamespace>;
-            };
-            eventName: K;
-            error: any;
-        } & (ClientEvents & NamespaceData[TNamespace]["customEvents"])[K];
-    }[keyof (ClientEvents & NamespaceData[TNamespace]["customEvents"])]) => Promise<boolean> | boolean, options?: {
-        once: boolean;
-    }): (() => any);
-    on(eventName: "interactionRateLimit", handler: (data: Omit<IDBIBaseExecuteCtx<TNamespace>, "other" | "setRateLimit"> & {
-        rateLimit: {
-            type: TDBIRateLimitTypes;
-            duration: number;
-            at: number;
-        };
-    }) => Promise<boolean> | boolean, options?: {
-        once: boolean;
-    }): (() => any);
-    off(eventName: TDBIEventNames, handler: (data: any) => Promise<boolean> | boolean): ((data: any) => boolean | Promise<boolean>)[];
-}
+import { NamespaceEnums, NamespaceData } from "../generated/namespaceData";
+import { DBI } from "./DBI";
+import { ClientEvents } from "./types/Event";
+import { IDBIBaseExecuteCtx, TDBIRateLimitTypes } from "./types/Interaction";
+import { DBILocale } from "./types/Locale";
+export declare type TDBIEventNames = "beforeInteraction" | "afterInteraction" | "interactionRateLimit" | "beforeEvent" | "afterEvent" | "interactionError" | "eventError";
+export declare class Events<TNamespace extends NamespaceEnums> {
+    DBI: DBI<TNamespace>;
+    handlers: Record<string, Array<(data: any) => boolean | Promise<boolean>>>;
+    constructor(DBI: DBI<TNamespace>);
+    trigger(name: TDBIEventNames, data: any): Promise<boolean>;
+    on(eventName: "beforeInteraction" | "afterInteraction", handler: (data: IDBIBaseExecuteCtx<TNamespace>) => Promise<boolean> | boolean, options?: {
+        once: boolean;
+    }): (() => any);
+    on(eventName: "interactionError", handler: (data: IDBIBaseExecuteCtx<TNamespace> & {
+        error: any;
+    }) => Promise<boolean> | boolean, options?: {
+        once: boolean;
+    }): (() => any);
+    on(eventName: "beforeEvent" | "afterEvent", handler: (data: {
+        [K in keyof (ClientEvents & NamespaceData[TNamespace]["customEvents"])]: {
+            other: Record<string, any>;
+            locale?: {
+                guild: DBILocale<TNamespace>;
+            };
+            eventName: K;
+        } & (ClientEvents & NamespaceData[TNamespace]["customEvents"])[K];
+    }[keyof (ClientEvents & NamespaceData[TNamespace]["customEvents"])]) => Promise<boolean> | boolean, options?: {
+        once: boolean;
+    }): (() => any);
+    on(eventName: "eventError", handler: (data: {
+        [K in keyof (ClientEvents & NamespaceData[TNamespace]["customEvents"])]: {
+            other: Record<string, any>;
+            locale?: {
+                guild: DBILocale<TNamespace>;
+            };
+            eventName: K;
+            error: any;
+        } & (ClientEvents & NamespaceData[TNamespace]["customEvents"])[K];
+    }[keyof (ClientEvents & NamespaceData[TNamespace]["customEvents"])]) => Promise<boolean> | boolean, options?: {
+        once: boolean;
+    }): (() => any);
+    on(eventName: "interactionRateLimit", handler: (data: Omit<IDBIBaseExecuteCtx<TNamespace>, "other" | "setRateLimit"> & {
+        rateLimit: {
+            type: TDBIRateLimitTypes;
+            duration: number;
+            at: number;
+        };
+    }) => Promise<boolean> | boolean, options?: {
+        once: boolean;
+    }): (() => any);
+    off(eventName: TDBIEventNames, handler: (data: any) => Promise<boolean> | boolean): ((data: any) => boolean | Promise<boolean>)[];
+}
 //# sourceMappingURL=Events.d.ts.map

package/dist/Events.js

@@ -1,59 +1,59 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Events = void 0;
-class Events {
-    DBI;
-    handlers;
-    constructor(DBI) {
-        this.DBI = DBI;
-        this.handlers = {
-            beforeInteraction: [],
-            afterInteraction: [],
-            interactionRateLimit: [],
-            beforeEvent: [],
-            afterEvent: [],
-            interactionError: [],
-            eventError: []
-        };
-    }
-    async trigger(name, data) {
-        let handlers = this.handlers[name];
-        if (!handlers)
-            return true;
-        for (let i = 0; i < handlers.length; i++) {
-            const handler = handlers[i];
-            let returned = await handler(data);
-            if (returned !== true)
-                return false;
-        }
-        return true;
-    }
-    on(eventName, handler, options = { once: false }) {
-        if (!this.handlers.hasOwnProperty(eventName))
-            this.handlers[eventName] = [];
-        if (options.once) {
-            let h = (data) => {
-                this.off(eventName, h);
-                return handler(data);
-            };
-            this.on(eventName, h, { once: false });
-            return () => {
-                this.off(eventName, h);
-            };
-        }
-        else {
-            this.handlers[eventName].push(handler);
-            return () => {
-                this.off(eventName, handler);
-            };
-        }
-    }
-    off(eventName, handler) {
-        let l = this.handlers[eventName];
-        if (!l)
-            return [];
-        return l.splice(l.indexOf(handler), 1);
-    }
-}
-exports.Events = Events;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Events = void 0;
+class Events {
+    DBI;
+    handlers;
+    constructor(DBI) {
+        this.DBI = DBI;
+        this.handlers = {
+            beforeInteraction: [],
+            afterInteraction: [],
+            interactionRateLimit: [],
+            beforeEvent: [],
+            afterEvent: [],
+            interactionError: [],
+            eventError: []
+        };
+    }
+    async trigger(name, data) {
+        let handlers = this.handlers[name];
+        if (!handlers)
+            return true;
+        for (let i = 0; i < handlers.length; i++) {
+            const handler = handlers[i];
+            let returned = await handler(data);
+            if (returned !== true)
+                return false;
+        }
+        return true;
+    }
+    on(eventName, handler, options = { once: false }) {
+        if (!this.handlers.hasOwnProperty(eventName))
+            this.handlers[eventName] = [];
+        if (options.once) {
+            let h = (data) => {
+                this.off(eventName, h);
+                return handler(data);
+            };
+            this.on(eventName, h, { once: false });
+            return () => {
+                this.off(eventName, h);
+            };
+        }
+        else {
+            this.handlers[eventName].push(handler);
+            return () => {
+                this.off(eventName, handler);
+            };
+        }
+    }
+    off(eventName, handler) {
+        let l = this.handlers[eventName];
+        if (!l)
+            return [];
+        return l.splice(l.indexOf(handler), 1);
+    }
+}
+exports.Events = Events;
 //# sourceMappingURL=Events.js.map