seyfert 3.2.1-dev-15624887796.0 → 3.2.1-dev-15657234528.0

package/lib/common/shorters/threads.d.ts

@@ -1,5 +1,5 @@
 import type { ThreadChannelStructure } from '../../client/transformers';
-import type { APIThreadMember, RESTGetAPIChannelThreadMembersQuery, RESTGetAPIChannelThreadsArchivedQuery, RESTPatchAPIChannelJSONBody, RESTPostAPIChannelMessagesThreadsJSONBody, RESTPostAPIChannelThreadsJSONBody, RESTPostAPIGuildForumThreadsJSONBody } from '../../types';
+import { type APIThreadMember, type RESTGetAPIChannelThreadMembersQuery, type RESTGetAPIChannelThreadsArchivedQuery, type RESTPatchAPIChannelJSONBody, type RESTPostAPIChannelMessagesThreadsJSONBody, type RESTPostAPIChannelThreadsJSONBody, type RESTPostAPIGuildForumThreadsJSONBody } from '../../types';
 import type { MakeRequired, When } from '../types/util';
 import { BaseShorter } from './base';
 export declare class ThreadShorter extends BaseShorter {
@@ -21,11 +21,12 @@ export declare class ThreadShorter extends BaseShorter {
     fetchMember<WithMember extends boolean = false>(threadId: string, memberId: string, with_member: WithMember): Promise<When<WithMember, Required<APIThreadMember>, GetAPIChannelThreadMemberResult>>;
     addMember(threadId: string, memberId: string): Promise<undefined>;
     listMembers<T extends RESTGetAPIChannelThreadMembersQuery = RESTGetAPIChannelThreadMembersQuery>(threadId: string, query?: T): Promise<InferWithMemberOnList<T>>;
-    listArchivedThreads(channelId: string, type: 'public' | 'private', query?: RESTGetAPIChannelThreadsArchivedQuery): Promise<{
+    listArchived(channelId: string, type: 'public' | 'private', query?: RESTGetAPIChannelThreadsArchivedQuery): Promise<{
         threads: ThreadChannelStructure[];
         members: GetAPIChannelThreadMemberResult[];
         hasMore: boolean;
     }>;
+    listGuildActive(guildId: string, force?: boolean): Promise<ThreadChannelStructure[]>;
     listJoinedArchivedPrivate(channelId: string, query?: RESTGetAPIChannelThreadsArchivedQuery): Promise<{
         threads: ThreadChannelStructure[];
         members: GetAPIChannelThreadMemberResult[];

package/lib/common/shorters/threads.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ThreadShorter = void 0;
 const __1 = require("../..");
 const structures_1 = require("../../structures");
+const types_1 = require("../../types");
 const base_1 = require("./base");
 class ThreadShorter extends base_1.BaseShorter {
     /**
@@ -21,16 +22,11 @@ class ThreadShorter extends base_1.BaseShorter {
             return (0, structures_1.channelFrom)(thread, this.client);
         }));
     }
-    fromMessage(channelId, messageId, options) {
+    async fromMessage(channelId, messageId, options) {
         const { reason, ...body } = options;
-        return this.client.proxy
-            .channels(channelId)
-            .messages(messageId)
-            .threads.post({ body, reason })
-            .then(async (thread) => {
-            await this.client.cache.channels?.setIfNI(__1.CacheFrom.Rest, 'Guilds', thread.id, thread.guild_id, thread);
-            return (0, structures_1.channelFrom)(thread, this.client);
-        });
+        const thread = await this.client.proxy.channels(channelId).messages(messageId).threads.post({ body, reason });
+        await this.client.cache.channels?.setIfNI(__1.CacheFrom.Rest, 'Guilds', thread.id, thread.guild_id, thread);
+        return await (0, structures_1.channelFrom)(thread, this.client);
     }
     join(threadId) {
         return this.client.proxy.channels(threadId)['thread-members']('@me').put();
@@ -38,8 +34,9 @@ class ThreadShorter extends base_1.BaseShorter {
     leave(threadId) {
         return this.client.proxy.channels(threadId)['thread-members']('@me').delete();
     }
-    lock(threadId, locked = true, reason) {
-        return this.edit(threadId, { locked }, reason).then(x => (0, structures_1.channelFrom)(x, this.client));
+    async lock(threadId, locked = true, reason) {
+        const x = await this.edit(threadId, { locked }, reason);
+        return (0, structures_1.channelFrom)(x, this.client);
     }
     async edit(threadId, body, reason) {
         return (await this.client.channels.edit(threadId, body, { reason }));
@@ -60,7 +57,7 @@ class ThreadShorter extends base_1.BaseShorter {
     listMembers(threadId, query) {
         return this.client.proxy.channels(threadId)['thread-members'].get({ query });
     }
-    async listArchivedThreads(channelId, type, query) {
+    async listArchived(channelId, type, query) {
         const data = await this.client.proxy.channels(channelId).threads.archived[type].get({ query });
         return {
             threads: data.threads.map(thread => (0, structures_1.channelFrom)(thread, this.client)),
@@ -68,6 +65,20 @@ class ThreadShorter extends base_1.BaseShorter {
             hasMore: data.has_more,
         };
     }
+    async listGuildActive(guildId, force = false) {
+        if (!force) {
+            const cached = await this.client.cache.channels?.valuesRaw(guildId);
+            if (cached)
+                return cached
+                    .filter(x => [types_1.ChannelType.PublicThread, types_1.ChannelType.PrivateThread, types_1.ChannelType.AnnouncementThread].includes(x.type))
+                    .map(x => (0, structures_1.channelFrom)(x, this.client));
+        }
+        const data = await this.client.proxy.guilds(guildId).threads.active.get();
+        return Promise.all(data.threads.map(async (thread) => {
+            await this.client.cache.channels?.setIfNI(__1.CacheFrom.Rest, 'Guilds', thread.id, guildId, thread);
+            return (0, structures_1.channelFrom)(thread, this.client);
+        }));
+    }
     async listJoinedArchivedPrivate(channelId, query) {
         const data = await this.client.proxy.channels(channelId).users('@me').threads.archived.private.get({ query });
         return {

package/lib/components/componentcommand.d.ts

@@ -10,7 +10,7 @@ export interface ComponentCommand {
 export declare abstract class ComponentCommand {
     type: 0;
     abstract componentType: keyof ContextComponentCommandInteractionMap;
-    customId?: string;
+    customId?: string | RegExp;
     filter?(context: ComponentContext<typeof this.componentType>): Promise<boolean> | boolean;
     abstract run(context: ComponentContext<typeof this.componentType>): any;
     middlewares: (keyof RegisteredMiddlewares)[];

package/lib/components/componentcommand.js

@@ -11,8 +11,11 @@ class ComponentCommand {
     customId;
     /** @internal */
     _filter(context) {
-        if (this.customId && this.customId !== context.customId)
-            return false;
+        if (this.customId) {
+            const matches = typeof this.customId === 'string' ? this.customId === context.customId : context.customId.match(this.customId);
+            if (!matches)
+                return false;
+        }
         if (this.filter)
             return this.filter(context);
         return true;

package/lib/components/handler.d.ts

@@ -29,6 +29,7 @@ export type ComponentCommands = ComponentCommand | ModalCommand;
 export interface CreateComponentCollectorResult {
     run<T extends CollectorInteraction = CollectorInteraction>(customId: UserMatches, callback: ComponentCallback<T>): void;
     stop(reason?: string): void;
+    waitFor<T extends CollectorInteraction = CollectorInteraction>(customId: UserMatches): Promise<T | null>;
     resetTimeouts(): void;
 }
 export declare class ComponentHandler extends BaseHandler {

package/lib/components/handler.js

@@ -73,6 +73,23 @@ class ComponentHandler extends common_1.BaseHandler {
                     this.createComponentCollector(messageId, channelId, guildId, options, old.components);
                 });
             },
+            waitFor: customId => new Promise(resolve => {
+                const collector = this.values.get(messageId);
+                if (!collector)
+                    return resolve(null);
+                this.values.get(messageId).__run(customId, interaction => {
+                    this.clearValue(messageId);
+                    //@ts-expect-error generic
+                    resolve(interaction);
+                });
+                if (collector?.timeout)
+                    clearTimeout(collector.timeout);
+                collector.timeout = setTimeout(() => {
+                    this.clearValue(messageId);
+                    resolve(null);
+                    // by default 15 seconds in case user don't do anything
+                }, collector?.options?.timeout ?? 15_000);
+            }),
             resetTimeouts: () => {
                 this.resetTimeouts(messageId);
             },

package/lib/langs/router.d.ts

@@ -14,4 +14,4 @@ export type __InternalParseLocale<T extends Record<string, any>> = {
     } : never;
 };
 export type ParseLocales<T extends Record<string, any>> = T;
-/**Idea inspiration from: FreeAoi */
+/**Idea inspiration from: FreeAoi | Fixed by: Drylozu */

package/lib/langs/router.js

@@ -13,6 +13,8 @@ const LangRouter = (userLocale, defaultLang, langs) => {
                         if (typeof locale === 'undefined')
                             throw new Error('Undefined locale');
                         let value = langs[locale];
+                        if (typeof value === 'undefined')
+                            throw new Error(`Locale "${locale}" not found`);
                         for (const i of route)
                             value = value[i];
                         return value;
@@ -39,4 +41,4 @@ const LangRouter = (userLocale, defaultLang, langs) => {
     return createProxy;
 };
 exports.LangRouter = LangRouter;
-/**Idea inspiration from: FreeAoi */
+/**Idea inspiration from: FreeAoi | Fixed by: Drylozu */

package/lib/structures/Guild.d.ts

@@ -1,4 +1,4 @@
-import type { GuildMemberStructure, GuildStructure } from '../client';
+import type { GuildMemberStructure, GuildStructure, ThreadChannelStructure } from '../client';
 import type { UsingClient } from '../commands';
 import type { CreateInviteFromChannel } from '../common';
 import type { ObjectToLower, StructPropState, StructStates, ToClass } from '../common/types/util';
@@ -20,6 +20,7 @@ export declare class Guild<State extends StructStates = 'api'> extends Guild_bas
     get maxStickers(): MaxStickers;
     get maxEmojis(): MaxEmojis;
     fetchOwner(force?: boolean): Promise<GuildMemberStructure | null>;
+    listActiveThreads(force?: boolean): Promise<ThreadChannelStructure[]>;
     templates: {
         fetch: (code: string) => Promise<import("../client").GuildTemplateStructure>;
         list: () => Promise<import("../client").GuildTemplateStructure[]>;

package/lib/structures/Guild.js

@@ -56,6 +56,9 @@ class Guild extends BaseGuild_1.BaseGuild {
         }
         return this.members.fetch(this.ownerId, force);
     }
+    listActiveThreads(force = false) {
+        return this.client.threads.listGuildActive(this.id, force);
+    }
     templates = GuildTemplate_1.GuildTemplate.methods({ client: this.client, guildId: this.id });
     stickers = Sticker_1.Sticker.methods({ client: this.client, guildId: this.id });
     members = GuildMember_1.GuildMember.methods({ client: this.client, guildId: this.id });

package/package.json

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