spacecommands 1.0.0

package/dist/handlers/EntitlementHandler.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Handler for Discord premium features and entitlements
+ * Supports Discord's monetization system with SKUs and subscriptions
+ */
+class EntitlementHandler {
+    _client;
+    _instance;
+    _skus = new Map();
+    _entitlementCache = new Map();
+    _cacheTimeout = 5 * 60 * 1000; // 5 minutes
+    constructor(instance) {
+        this._instance = instance;
+        this._client = instance.client;
+        this.setUp();
+    }
+    setUp() {
+        // Listen for new entitlements
+        this._client.on('entitlementCreate', (entitlement) => {
+            this.clearUserCache(entitlement.userId);
+            if (this._instance.debug) {
+                console.log(`SpaceCommands > Entitlement created: ${entitlement.id} for user ${entitlement.userId}`);
+            }
+        });
+        // Listen for entitlement updates
+        this._client.on('entitlementUpdate', (oldEntitlement, newEntitlement) => {
+            this.clearUserCache(newEntitlement.userId);
+            if (this._instance.debug) {
+                console.log(`SpaceCommands > Entitlement updated: ${newEntitlement.id} for user ${newEntitlement.userId}`);
+            }
+        });
+        // Listen for entitlement deletions
+        this._client.on('entitlementDelete', (entitlement) => {
+            this.clearUserCache(entitlement.userId);
+            if (this._instance.debug) {
+                console.log(`SpaceCommands > Entitlement deleted: ${entitlement.id} for user ${entitlement.userId}`);
+            }
+        });
+    }
+    /**
+     * Register a SKU for premium features
+     */
+    registerSKU(config) {
+        this._skus.set(config.skuId, config);
+        if (this._instance.debug) {
+            console.log(`SpaceCommands > Registered SKU: ${config.skuId} (${config.name || 'Unnamed'})`);
+        }
+        return this;
+    }
+    /**
+     * Register multiple SKUs at once
+     */
+    registerSKUs(configs) {
+        for (const config of configs) {
+            this.registerSKU(config);
+        }
+        return this;
+    }
+    /**
+     * Check if a user has a specific entitlement
+     */
+    async hasEntitlement(userId, skuId) {
+        const entitlements = await this.getUserEntitlements(userId);
+        const entitlement = entitlements.find((e) => e.skuId === skuId);
+        return {
+            hasEntitlement: !!entitlement,
+            entitlement,
+        };
+    }
+    /**
+     * Check if a user has any of the specified entitlements
+     */
+    async hasAnyEntitlement(userId, skuIds) {
+        const entitlements = await this.getUserEntitlements(userId);
+        const entitlement = entitlements.find((e) => skuIds.includes(e.skuId));
+        return {
+            hasEntitlement: !!entitlement,
+            entitlement,
+        };
+    }
+    /**
+     * Check if a user has all of the specified entitlements
+     */
+    async hasAllEntitlements(userId, skuIds) {
+        const entitlements = await this.getUserEntitlements(userId);
+        const entitlementSkus = entitlements.map((e) => e.skuId);
+        return skuIds.every((skuId) => entitlementSkus.includes(skuId));
+    }
+    /**
+     * Get all active entitlements for a user
+     */
+    async getUserEntitlements(userId, useCache = true) {
+        // Check cache first
+        if (useCache && this._entitlementCache.has(userId)) {
+            return this._entitlementCache.get(userId);
+        }
+        try {
+            const entitlements = await this._client.application?.entitlements.fetch({
+                user: userId,
+            });
+            if (!entitlements) {
+                return [];
+            }
+            const activeEntitlements = entitlements.filter((e) => !e.deleted && e.endsAt && e.endsAt.getTime() > Date.now());
+            // Cache the results
+            this._entitlementCache.set(userId, Array.from(activeEntitlements.values()));
+            // Clear cache after timeout
+            setTimeout(() => {
+                this._entitlementCache.delete(userId);
+            }, this._cacheTimeout);
+            return Array.from(activeEntitlements.values());
+        }
+        catch (error) {
+            console.error(`SpaceCommands > Error fetching entitlements for user ${userId}:`, error);
+            return [];
+        }
+    }
+    /**
+     * Get all registered SKUs
+     */
+    getSKUs() {
+        return this._skus;
+    }
+    /**
+     * Get a specific SKU configuration
+     */
+    getSKU(skuId) {
+        return this._skus.get(skuId);
+    }
+    /**
+     * Clear the entitlement cache for a specific user
+     */
+    clearUserCache(userId) {
+        if (userId) {
+            this._entitlementCache.delete(userId);
+        }
+        else {
+            this._entitlementCache.clear();
+        }
+    }
+    /**
+     * Set the cache timeout duration (in milliseconds)
+     */
+    setCacheTimeout(timeout) {
+        this._cacheTimeout = timeout;
+        return this;
+    }
+    /**
+     * Check if a user/member has entitlement (works with User or GuildMember)
+     */
+    async checkAccess(userOrMember, skuId) {
+        const userId = userOrMember.id;
+        return this.hasEntitlement(userId, skuId);
+    }
+    /**
+     * Consume a one-time purchase entitlement
+     * This marks the entitlement as consumed (for one-time purchases)
+     */
+    async consumeEntitlement(entitlementId) {
+        try {
+            await this._client.application?.entitlements.consume(entitlementId);
+            if (this._instance.debug) {
+                console.log(`SpaceCommands > Consumed entitlement: ${entitlementId}`);
+            }
+            return true;
+        }
+        catch (error) {
+            console.error(`SpaceCommands > Error consuming entitlement ${entitlementId}:`, error);
+            return false;
+        }
+    }
+    /**
+     * Get all entitlements for a guild
+     */
+    async getGuildEntitlements(guildId, useCache = false) {
+        try {
+            const entitlements = await this._client.application?.entitlements.fetch({
+                guild: guildId,
+            });
+            if (!entitlements) {
+                return [];
+            }
+            const activeEntitlements = entitlements.filter((e) => !e.deleted && e.endsAt && e.endsAt.getTime() > Date.now());
+            return Array.from(activeEntitlements.values());
+        }
+        catch (error) {
+            console.error(`SpaceCommands > Error fetching entitlements for guild ${guildId}:`, error);
+            return [];
+        }
+    }
+}
+exports.default = EntitlementHandler;

package/dist/handlers/ModalHandler.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const get_all_files_1 = __importDefault(require("../get-all-files"));
+class ModalHandler {
+    _client;
+    _instance;
+    _modalHandlers = new Map();
+    constructor(instance, modalsDir, typeScript = false) {
+        this._instance = instance;
+        this._client = instance.client;
+        this.setUp(modalsDir, typeScript);
+    }
+    async setUp(modalsDir, typeScript = false) {
+        // Listen for modal submissions
+        this._client.on('interactionCreate', async (interaction) => {
+            if (!interaction.isModalSubmit()) {
+                return;
+            }
+            const customId = interaction.customId;
+            await this.handleModal(interaction, customId);
+        });
+        // Load custom modal handlers if directory provided
+        if (modalsDir) {
+            await this.loadModalHandlers(modalsDir, typeScript);
+        }
+    }
+    async loadModalHandlers(dir, typeScript) {
+        const files = (0, get_all_files_1.default)(dir, typeScript ? '.ts' : '');
+        for (const [file, fileName] of files) {
+            const handler = require(file);
+            const config = handler.default || handler;
+            if (config.type === 'modal') {
+                this.registerModalHandler(config);
+            }
+        }
+    }
+    registerModalHandler(handler) {
+        const key = typeof handler.customId === 'string'
+            ? handler.customId
+            : handler.customId.source;
+        this._modalHandlers.set(key, handler);
+    }
+    async handleModal(interaction, customId) {
+        for (const [key, handler] of this._modalHandlers.entries()) {
+            const regex = handler.customId instanceof RegExp ? handler.customId : null;
+            if ((regex && regex.test(customId)) ||
+                (!regex && handler.customId === customId)) {
+                try {
+                    await handler.callback(interaction, this._instance);
+                }
+                catch (error) {
+                    console.error(`SpaceCommands > Error handling modal "${customId}":`, error);
+                    if (!interaction.replied && !interaction.deferred) {
+                        await interaction.reply({
+                            content: 'An error occurred while processing this form.',
+                            ephemeral: true,
+                        });
+                    }
+                }
+                return;
+            }
+        }
+    }
+    get modalHandlers() {
+        return this._modalHandlers;
+    }
+}
+exports.default = ModalHandler;

package/dist/handlers/PollHandler.js

@@ -0,0 +1,230 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Handler for Discord Polls
+ * Supports creating, managing, and listening to poll events
+ */
+class PollHandler {
+    _client;
+    _instance;
+    _voteHandlers = new Map();
+    _endHandlers = [];
+    constructor(instance) {
+        this._instance = instance;
+        this._client = instance.client;
+        this.setUp();
+    }
+    setUp() {
+        // Note: Discord.js doesn't have built-in poll events yet
+        // Polls are accessed through messages
+        // This handler provides utilities for working with polls
+    }
+    /**
+     * Create a poll in a message
+     * Returns the message containing the poll
+     */
+    async createPoll(message, config) {
+        try {
+            if (config.answers.length < 1 || config.answers.length > 10) {
+                throw new Error('Polls must have between 1 and 10 answers');
+            }
+            const duration = config.duration
+                ? Math.min(Math.max(config.duration, 1), 168)
+                : 24;
+            // Poll creation is done through the message content
+            // This is a utility method to help construct poll data
+            const pollData = {
+                question: { text: config.question },
+                answers: config.answers.map((answer, index) => ({
+                    poll_media: {
+                        text: answer.text,
+                        emoji: answer.emoji,
+                    },
+                    answer_id: index,
+                })),
+                duration,
+                allow_multiselect: config.allowMultiselect || false,
+                layout_type: config.layoutType || 1,
+            };
+            // Fetch the message to get the poll if it was created
+            const fetchedMessage = await message.channel.messages.fetch(message.id);
+            return fetchedMessage.poll || null;
+        }
+        catch (error) {
+            console.error('SpaceCommands > Error creating poll:', error);
+            return null;
+        }
+    }
+    /**
+     * Get poll results
+     */
+    async getPollResults(poll) {
+        const results = new Map();
+        try {
+            for (const answer of poll.answers.values()) {
+                const voters = await answer.fetchVoters();
+                results.set(answer.id, voters);
+            }
+        }
+        catch (error) {
+            console.error('SpaceCommands > Error fetching poll results:', error);
+        }
+        return results;
+    }
+    /**
+     * Get the winning answer(s) of a poll
+     */
+    getWinningAnswers(poll) {
+        const answers = Array.from(poll.answers.values());
+        if (answers.length === 0)
+            return [];
+        const maxVotes = Math.max(...answers.map((a) => a.voteCount));
+        return answers.filter((a) => a.voteCount === maxVotes);
+    }
+    /**
+     * End a poll early
+     */
+    async endPoll(poll) {
+        try {
+            await poll.end();
+            if (this._instance.debug) {
+                console.log(`SpaceCommands > Ended poll: ${poll.message.id}`);
+            }
+            // Trigger end handlers
+            await this.triggerEndHandlers(poll);
+            return true;
+        }
+        catch (error) {
+            console.error('SpaceCommands > Error ending poll:', error);
+            return false;
+        }
+    }
+    /**
+     * Register a handler for when a poll ends
+     */
+    registerPollEndHandler(handler) {
+        this._endHandlers.push(handler);
+        if (this._instance.debug) {
+            console.log(`SpaceCommands > Registered poll end handler for: ${handler.pollId}`);
+        }
+        return this;
+    }
+    /**
+     * Trigger all matching end handlers for a poll
+     */
+    async triggerEndHandlers(poll) {
+        const pollId = poll.message.id;
+        for (const handler of this._endHandlers) {
+            let matches = false;
+            if (typeof handler.pollId === 'string') {
+                matches = handler.pollId === pollId;
+            }
+            else {
+                matches = handler.pollId.test(pollId);
+            }
+            if (matches) {
+                try {
+                    await handler.callback(poll, this._instance);
+                }
+                catch (error) {
+                    console.error('SpaceCommands > Error executing poll end handler:', error);
+                }
+            }
+        }
+    }
+    /**
+     * Check if a user has voted on a poll
+     */
+    async hasUserVoted(poll, userId) {
+        try {
+            for (const answer of poll.answers.values()) {
+                const voters = await answer.fetchVoters();
+                if (voters.has(userId)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        catch (error) {
+            console.error('SpaceCommands > Error checking poll vote:', error);
+            return false;
+        }
+    }
+    /**
+     * Get user's votes on a poll
+     */
+    async getUserVotes(poll, userId) {
+        const userVotes = [];
+        try {
+            for (const answer of poll.answers.values()) {
+                const voters = await answer.fetchVoters();
+                if (voters.has(userId)) {
+                    userVotes.push(answer);
+                }
+            }
+        }
+        catch (error) {
+            console.error('SpaceCommands > Error getting user votes:', error);
+        }
+        return userVotes;
+    }
+    /**
+     * Get poll statistics
+     */
+    getPollStats(poll) {
+        const answers = Array.from(poll.answers.values());
+        const totalVotes = answers.reduce((sum, answer) => sum + answer.voteCount, 0);
+        return {
+            totalVotes,
+            answerCount: answers.length,
+            allowsMultiselect: poll.allowMultiselect,
+            expiresAt: poll.expiresAt,
+            isExpired: poll.expiresAt ? poll.expiresAt.getTime() < Date.now() : false,
+        };
+    }
+    /**
+     * Get a formatted summary of poll results
+     */
+    async getFormattedResults(poll) {
+        const results = await this.getPollResults(poll);
+        const stats = this.getPollStats(poll);
+        let output = `**${poll.question.text}**\n\n`;
+        for (const answer of poll.answers.values()) {
+            const voters = results.get(answer.id);
+            const percentage = stats.totalVotes > 0
+                ? ((answer.voteCount / stats.totalVotes) * 100).toFixed(1)
+                : '0.0';
+            const answerText = 'text' in answer ? answer.text : answer.id.toString();
+            output += `${answerText}: ${answer.voteCount} votes (${percentage}%)\n`;
+        }
+        output += `\nTotal Votes: ${stats.totalVotes}`;
+        return output;
+    }
+    /**
+     * Fetch a poll from a message
+     */
+    async fetchPoll(message, channelId) {
+        try {
+            let msg;
+            if (typeof message === 'string') {
+                if (!channelId) {
+                    throw new Error('Channel ID required when fetching by message ID');
+                }
+                const channel = await this._client.channels.fetch(channelId);
+                if (!channel || !channel.isTextBased()) {
+                    throw new Error('Invalid channel');
+                }
+                msg = await channel.messages.fetch(message);
+            }
+            else {
+                msg = message;
+            }
+            return msg.poll || null;
+        }
+        catch (error) {
+            console.error('SpaceCommands > Error fetching poll:', error);
+            return null;
+        }
+    }
+}
+exports.default = PollHandler;