seyfert 2.2.1-dev-13493266703.0 → 2.2.1-dev-13573766445.0

package/lib/builders/types.d.ts

@@ -3,6 +3,7 @@ import type { Button } from './Button';
 import type { TextInput } from './Modal';
 import type { BuilderSelectMenus } from './SelectMenu';
 export type ComponentCallback<T extends ComponentInteraction | StringSelectMenuInteraction = ComponentInteraction | StringSelectMenuInteraction> = (interaction: T, stop: ComponentStopCallback, refresh: ComponentRefreshCallback) => any;
+export type ComponentOnErrorCallback<T extends ComponentInteraction | StringSelectMenuInteraction = ComponentInteraction | StringSelectMenuInteraction> = (interaction: T, error: unknown, stop: ComponentStopCallback, refresh: ComponentRefreshCallback) => any;
 export type ComponentFilterCallback<T = ComponentInteraction> = (interaction: T) => any;
 export type ComponentStopCallback = (reason: 'messageDelete' | 'channelDelete' | 'guildDelete' | 'idle' | 'timeout' | (string & {}) | undefined, refresh: ComponentRefreshCallback) => any;
 export type ComponentRefreshCallback = () => any;
@@ -19,4 +20,5 @@ export interface ListenerOptions {
     filter?: ComponentFilterCallback;
     onPass?: ComponentFilterCallback;
     onStop?: ComponentStopCallback;
+    onError?: ComponentOnErrorCallback;
 }

package/lib/components/handler.d.ts

@@ -1,4 +1,4 @@
-import type { ComponentCallback, ListenerOptions, ModalSubmitCallback } from '../builders/types';
+import type { ComponentCallback, ComponentOnErrorCallback, ListenerOptions, ModalSubmitCallback } from '../builders/types';
 import { LimitedCollection } from '../collection';
 import { type UsingClient } from '../commands';
 import type { FileLoaded } from '../commands/handler';
@@ -20,6 +20,7 @@ type COMPONENTS = {
     guildId: string | undefined;
     idle?: NodeJS.Timeout;
     timeout?: NodeJS.Timeout;
+    onError?: ComponentOnErrorCallback;
     __run: (customId: UserMatches, callback: ComponentCallback) => any;
 };
 export type MatchCallback = (str: string) => boolean;

package/lib/components/handler.js

@@ -60,6 +60,7 @@ class ComponentHandler extends common_1.BaseHandler {
                     });
                 }
             },
+            onError: options.onError,
         });
         return {
             //@ts-expect-error generic
@@ -84,14 +85,31 @@ class ComponentHandler extends common_1.BaseHandler {
                 return row.options.onPass?.(interaction);
         }
         row.idle?.refresh();
-        await component.callback(interaction, reason => {
+        const stop = reason => {
             this.clearValue(id);
             row.options?.onStop?.(reason ?? 'stop', () => {
                 this.createComponentCollector(row.messageId, row.channelId, row.guildId, row.options, row.components);
             });
-        }, () => {
+        };
+        const refresh = () => {
             this.resetTimeouts(id);
-        });
+        };
+        try {
+            await component.callback(interaction, stop, refresh);
+        }
+        catch (err) {
+            try {
+                if (row.onError) {
+                    await row.onError(interaction, err, stop, refresh);
+                }
+                else {
+                    this.client.logger.error('<Client>.components.onComponent', err);
+                }
+            }
+            catch (err) {
+                this.client.logger.error('<Client>.components.onComponent', err);
+            }
+        }
     }
     hasComponent(id, customId) {
         return this.values.get(id)?.components?.some(x => x.match(customId));

package/lib/deps/mixer.d.ts

@@ -1,8 +1,4 @@
-/**
- * Mixes a class with other classes.
- * @param args The classes to mix.
- * @returns The mixed class.
- */
-export declare function Mixin<T, C extends TypeClass[]>(...args: C): C[number] & T;
+export declare function copyProperties(target: InstanceType<TypeClass>, source: TypeClass): void;
+export declare function Mixin<T, C extends TypeClass[]>(...mixins: C): C[number] & T;
 export type TypeClass<InstanceType = object, StaticType = object> = (abstract new (...args: any[]) => InstanceType) & StaticType;
 export declare const mix: (...ingredients: TypeClass[]) => (decoratedClass: any) => any;

package/lib/deps/mixer.js

@@ -1,76 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mix = void 0;
+exports.copyProperties = copyProperties;
 exports.Mixin = Mixin;
-/**
- * Gets the descriptors of a class.
- * @param c The class to get the descriptors of.
- * @returns The descriptors of the class.
- */
-function getDenoDescriptors(c) {
-    const protos = [c.prototype];
-    let v = c;
-    while ((v = Object.getPrototypeOf(v))) {
-        if (v.prototype)
-            protos.push(v.prototype);
-    }
-    return protos.map(x => Object.getOwnPropertyDescriptors(x));
-}
-/**
- * Gets the descriptors of a class.
- * @param c The class to get the descriptors of.
- * @returns The descriptors of the class.
- */
-function getNodeDescriptors(c) {
-    let proto = c.prototype;
-    const result = [];
-    while (proto) {
-        const descriptors = Object.getOwnPropertyDescriptors(proto);
-        // @ts-expect-error this is not a function in all cases
-        if (descriptors.valueOf.configurable)
-            break;
-        result.push(descriptors);
-        proto = Object.getPrototypeOf(proto);
+const IgnoredProps = ['constructor', 'prototype', 'name'];
+function copyProperties(target, source) {
+    const keys = Reflect.ownKeys(source);
+    for (const key of keys) {
+        if (IgnoredProps.includes(key))
+            continue;
+        if (key in target)
+            continue;
+        const descriptor = Object.getOwnPropertyDescriptor(source, key);
+        if (descriptor) {
+            Object.defineProperty(target, key, descriptor);
+        }
     }
-    return result;
-}
-function getDescriptors(c) {
-    //@ts-expect-error
-    // biome-ignore lint/correctness/noUndeclaredVariables: <explanation>
-    return typeof Deno === 'undefined' ? getNodeDescriptors(c) : getDenoDescriptors(c);
 }
-/**
- * Mixes a class with other classes.
- * @param args The classes to mix.
- * @returns The mixed class.
- */
-function Mixin(...args) {
-    const Base = args[0];
+function Mixin(...mixins) {
+    const Base = mixins[0];
     class MixedClass extends Base {
-        constructor(...constructorArgs) {
-            super(...constructorArgs);
-            for (const mixin of args.slice(1)) {
-                const descriptors = getDescriptors(mixin).reverse();
-                for (const desc of descriptors) {
-                    // @ts-expect-error
-                    Object.assign(this, new desc.constructor.value(...constructorArgs));
-                    for (const key in desc) {
-                        if (key === 'constructor')
-                            continue;
-                        if (key in MixedClass.prototype)
-                            continue;
-                        const descriptor = desc[key];
-                        if (descriptor.value) {
-                            // @ts-expect-error
-                            MixedClass.prototype[key] = descriptor.value;
-                        }
-                        else if (descriptor.get || descriptor.set) {
-                            Object.defineProperty(MixedClass.prototype, key, {
-                                get: descriptor.get,
-                                set: descriptor.set,
-                            });
-                        }
-                    }
+        constructor(...args) {
+            super(...args);
+            for (const mixin of mixins.slice(1)) {
+                // @ts-expect-error
+                const mixinInstance = new mixin(...args);
+                copyProperties(this, mixinInstance);
+                let proto = Object.getPrototypeOf(mixinInstance);
+                while (proto && proto !== Object.prototype) {
+                    copyProperties(this, proto);
+                    proto = Object.getPrototypeOf(proto);
                 }
             }
         }

package/lib/structures/extra/Base.d.ts

@@ -1,6 +1,6 @@
 import type { UsingClient } from '../../commands';
 /** */
-export declare abstract class Base {
+export declare class Base {
     constructor(client: UsingClient);
     readonly client: UsingClient;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "seyfert",
-	"version": "2.2.1-dev-13493266703.0",
+	"version": "2.2.1-dev-13573766445.0",
 	"description": "The most advanced framework for discord bots",
 	"main": "./lib/index.js",
 	"module": "./lib/index.js",