@kevlid/discordmenus 0.0.2

package/src/handle/component.js

@@ -0,0 +1,379 @@
+const { decodeId, Presets } = require("../utils/customIds");
+const { EphemeralMessageFlag } = require("../utils/constants");
+const { OptionTypes, ResponseTypes } = require("../utils/types");
+const {
+    arrayClone,
+    asObject,
+    objectDefaultsFromKeys,
+    objectListPropertyKey,
+    objectListItemFailsRequired,
+    listJumpSize,
+    shapeObjectListItem,
+    normalizeObjectListItems,
+} = require("../utils/helpers");
+
+function ephemeral(content) {
+    return {
+        type: ResponseTypes.ChannelMessageWithSource,
+        data: { flags: EphemeralMessageFlag, content },
+    };
+}
+
+function updateMessage(data) {
+    return { type: ResponseTypes.UpdateMessage, data };
+}
+
+function openModal(data) {
+    return { type: ResponseTypes.Modal, data };
+}
+
+async function handleListBranch({
+    menu,
+    menu_key,
+    renderMenu,
+    values,
+    options,
+    category,
+    page,
+    userId,
+    guildId,
+}) {
+    const optionKey = values[0];
+    const subAction = values[2];
+    const sub = parseInt(options.get("sub") ?? 0);
+    const option = menu.getOption(category, page, optionKey);
+    const objectItems = option && option.itemType === OptionTypes.Object;
+    const menuCtx = { category, index: page, userId, guildId };
+
+    switch (subAction) {
+        case Presets.view:
+            if (objectItems) {
+                return updateMessage(
+                    await menu.renderListObjectItemPage(optionKey, 0, { ...menuCtx, listPage: 0 }),
+                );
+            }
+            return updateMessage(await menu.renderListPage(optionKey, 0, menuCtx));
+
+        case Presets.nav: {
+            const targetPage = parseInt(values[3] ?? 0);
+            return updateMessage(await menu.renderListPage(optionKey, targetPage, menuCtx));
+        }
+
+        case Presets.edit: {
+            const itemIndex = parseInt(values[3]);
+            if (objectItems) {
+                return updateMessage(
+                    await menu.renderListObjectItemPage(optionKey, itemIndex, { ...menuCtx, listPage: sub }),
+                );
+            }
+            return openModal(await menu.renderListModal(optionKey, itemIndex, { ...menuCtx, sub }));
+        }
+
+        case Presets.add:
+            if (objectItems) {
+                const props = option.itemConfig.properties;
+                const addItems = normalizeObjectListItems(
+                    props,
+                    arrayClone(await menu.get(optionKey, { guildId, userId })),
+                );
+                addItems.push(shapeObjectListItem(props, {}));
+                await menu.save(optionKey, addItems, { guildId, userId });
+                return updateMessage(
+                    await menu.renderListObjectItemPage(optionKey, addItems.length - 1, {
+                        ...menuCtx,
+                        listPage: sub,
+                    }),
+                );
+            }
+            return openModal(await menu.renderListModal(optionKey, null, { ...menuCtx, sub }));
+
+        case Presets.listItemView: {
+            const itemIndex = parseInt(values[3]);
+            return updateMessage(
+                await menu.renderListObjectItemPage(optionKey, itemIndex, { ...menuCtx, listPage: sub }),
+            );
+        }
+
+        case Presets.previousCategory:
+        case Presets.nextCategory:
+            if (objectItems) {
+                const jumpItems = arrayClone(await menu.get(optionKey, { guildId, userId }));
+                const currentItemIndex = parseInt(options.get("item") ?? 0);
+                const delta = subAction === Presets.previousCategory ? -listJumpSize(jumpItems.length) : listJumpSize(jumpItems.length);
+                return updateMessage(
+                    await menu.renderListObjectItemPage(optionKey, currentItemIndex + delta, {
+                        ...menuCtx,
+                        listPage: sub,
+                    }),
+                );
+            }
+            return updateMessage(await menu.renderListPage(optionKey, sub, menuCtx));
+
+        case Presets.listItemDone: {
+            const itemIndex = parseInt(options.get("item") ?? -1);
+            if (objectItems && itemIndex >= 0) {
+                const doneItems = arrayClone(await menu.get(optionKey, { guildId, userId }));
+                const currentItem = doneItems[itemIndex];
+                if (objectListItemFailsRequired(option, currentItem)) {
+                    doneItems.splice(itemIndex, 1);
+                    await menu.save(
+                        optionKey,
+                        normalizeObjectListItems(option.itemConfig.properties, doneItems),
+                        { guildId, userId },
+                    );
+                }
+                return updateMessage(await renderMenu(menu_key, menuCtx));
+            }
+            return updateMessage(await menu.renderListPage(optionKey, sub, menuCtx));
+        }
+
+        case Presets.listItemField: {
+            const itemIndex = parseInt(values[3]);
+            const propertyKey = objectListPropertyKey(option, values[4]);
+            return openModal(
+                await menu.renderListObjectItemModal(optionKey, propertyKey, itemIndex, {
+                    ...menuCtx,
+                    sub,
+                }),
+            );
+        }
+
+        case Presets.listItemBoolToggle: {
+            const itemIndex = parseInt(values[3]);
+            const propertyKey = objectListPropertyKey(option, values[4]);
+            const newBoolValue = values[5] === "true";
+            const props = option.itemConfig.properties;
+            const boolItems = normalizeObjectListItems(
+                props,
+                arrayClone(await menu.get(optionKey, { guildId, userId })),
+            );
+            boolItems[itemIndex] = shapeObjectListItem(props, {
+                ...asObject(boolItems[itemIndex]),
+                [propertyKey]: newBoolValue,
+            });
+            await menu.save(optionKey, boolItems, { guildId, userId });
+            return updateMessage(
+                await menu.renderListObjectItemPage(optionKey, itemIndex, { ...menuCtx, listPage: sub }),
+            );
+        }
+
+        case Presets.delete: {
+            const itemIndex = parseInt(values[3]);
+            const props = option.itemConfig.properties;
+            let deleteItems = arrayClone(await menu.get(optionKey, { guildId, userId }));
+            if (objectItems) {
+                deleteItems = normalizeObjectListItems(props, deleteItems);
+            }
+            deleteItems.splice(itemIndex, 1);
+            await menu.save(optionKey, deleteItems, { guildId, userId });
+            if (objectItems) {
+                if (deleteItems.length <= 0) {
+                    return updateMessage(await renderMenu(menu_key, menuCtx));
+                }
+                const nextIndex = Math.max(0, Math.min(itemIndex, deleteItems.length - 1));
+                return updateMessage(
+                    await menu.renderListObjectItemPage(optionKey, nextIndex, { ...menuCtx, listPage: sub }),
+                );
+            }
+            return updateMessage(await menu.renderListPage(optionKey, sub, menuCtx));
+        }
+
+        case Presets.done:
+            return updateMessage(await renderMenu(menu_key, menuCtx));
+
+        default:
+            return null;
+    }
+}
+
+async function handleObjectBranch({
+    menu,
+    menu_key,
+    renderMenu,
+    values,
+    options,
+    category,
+    page,
+    userId,
+    guildId,
+}) {
+    const objectKey = values[0];
+    const subAction = values[2];
+    const sub = parseInt(options.get("sub") ?? 0);
+    const objectPage = parseInt(options.get("op") ?? 0);
+    const menuCtx = { category, index: page, userId, guildId };
+    const objectCtx = { ...menuCtx, objectPage };
+
+    if (subAction === Presets.view) {
+        return updateMessage(await menu.renderObjectPage(objectKey, objectCtx));
+    }
+    if (subAction === Presets.nav) {
+        const targetObjectPage = parseInt(values[3] ?? 0);
+        return updateMessage(await menu.renderObjectPage(objectKey, { ...menuCtx, objectPage: targetObjectPage }));
+    }
+    if (subAction === Presets.done) {
+        return updateMessage(await renderMenu(menu_key, menuCtx));
+    }
+    if (subAction === Presets.subBoolean) {
+        const subKey = values[3];
+        const newValue = values[4] === "true";
+        const boolObjectOption = menu.getOption(category, page, objectKey);
+        const baseObj = asObject(await menu.get(objectKey, { guildId, userId }));
+        const defaults = boolObjectOption ? objectDefaultsFromKeys(boolObjectOption.options) : {};
+        const updatedObj = Object.assign(defaults, baseObj);
+        updatedObj[subKey] = newValue;
+        await menu.save(objectKey, updatedObj, { guildId, userId });
+        return updateMessage(await menu.renderObjectPage(objectKey, objectCtx));
+    }
+    if (subAction === Presets.subModal) {
+        const subKey = values[3];
+        return openModal(await menu.renderObjectModal(objectKey, subKey, { ...menuCtx, objectPage }));
+    }
+    if (subAction !== Presets.subList) {
+        return null;
+    }
+
+    const subKey = values[3];
+    const listAction = values[4];
+    const objectOption = menu.getOption(category, page, objectKey);
+    const subOption = objectOption?.options.find(o => o.key === subKey);
+
+    if (listAction === Presets.view) {
+        return updateMessage(
+            await menu.renderObjectListPage(objectKey, subKey, 0, { ...menuCtx, objectPage }),
+        );
+    }
+    if (listAction === Presets.nav) {
+        const targetPage = parseInt(values[5] ?? 0);
+        return updateMessage(
+            await menu.renderObjectListPage(objectKey, subKey, targetPage, { ...menuCtx, objectPage }),
+        );
+    }
+    if (listAction === Presets.done) {
+        return updateMessage(await menu.renderObjectPage(objectKey, objectCtx));
+    }
+    if (listAction === Presets.add) {
+        return openModal(
+            await menu.renderObjectListModal(objectKey, subKey, null, {
+                ...menuCtx,
+                sub,
+                objectPage,
+            }),
+        );
+    }
+    if (listAction === Presets.edit) {
+        const itemIndex = parseInt(values[5]);
+        return openModal(
+            await menu.renderObjectListModal(objectKey, subKey, itemIndex, {
+                ...menuCtx,
+                sub,
+                objectPage,
+            }),
+        );
+    }
+    if (listAction === Presets.delete) {
+        const itemIndex = parseInt(values[5]);
+        const obj = asObject(await menu.get(objectKey, { guildId, userId }));
+        const items = arrayClone(obj[subKey]);
+        items.splice(itemIndex, 1);
+        await menu.save(objectKey, Object.assign({}, obj, { [subKey]: items }), { guildId, userId });
+        return updateMessage(
+            await menu.renderObjectListPage(objectKey, subKey, sub, { ...menuCtx, objectPage }),
+        );
+    }
+    return null;
+}
+
+async function handleComponent(interaction, menu, menu_key, renderMenu) {
+    const guildId = interaction.guildId ?? null;
+    const interactionData = interaction.data ?? {};
+    const customId = interactionData.custom_id;
+    if (!customId) {
+        throw new Error("Invalid interaction payload: missing custom_id");
+    }
+    const { values, options } = decodeId(customId);
+    const userId = interaction.member?.user?.id ?? interaction.user?.id ?? null;
+
+    if (values.length <= 0) {
+        throw new Error("Invalid custom ID");
+    }
+
+    if (options.get("u") && String(options.get("u")) !== String(userId)) {
+        return ephemeral("This menu doesn't belong to you.");
+    }
+
+    if (menu.permissions.length > 0 && values[1] !== Presets.nav) {
+        const memberPerms = BigInt(interaction.member?.permissions ?? 0);
+        const allowed = menu.permissions.some(stack =>
+            stack.every(p => (memberPerms & BigInt(p)) === BigInt(p)),
+        );
+        if (!allowed) {
+            return ephemeral("You are missing the required permissions");
+        }
+    }
+
+    const category = parseInt(options.get("cat") ?? 0);
+    const page = parseInt(options.get("page") ?? 0);
+    const action = values[1];
+
+    let result;
+
+    if (action === Presets.nav) {
+        result = updateMessage(
+            await renderMenu(menu_key, { category, index: page, userId, guildId }),
+        );
+    } else if (action === OptionTypes.String || action === OptionTypes.Number) {
+        result = openModal(await menu.renderModal(values[0], { category, index: page, guildId }));
+    } else if (action === OptionTypes.Boolean) {
+        await menu.save(values[0], values[2] === "true", { guildId, userId });
+        result = updateMessage(
+            await renderMenu(menu_key, { category, index: page, userId, guildId }),
+        );
+    } else if (action === OptionTypes.List) {
+        result = await handleListBranch({
+            menu,
+            menu_key,
+            renderMenu,
+            values,
+            options,
+            category,
+            page,
+            userId,
+            guildId,
+        });
+    } else if (action === OptionTypes.Object) {
+        result = await handleObjectBranch({
+            menu,
+            menu_key,
+            renderMenu,
+            values,
+            options,
+            category,
+            page,
+            userId,
+            guildId,
+        });
+    } else if (
+        action === OptionTypes.StringSelect ||
+        action === OptionTypes.UserSelect ||
+        action === OptionTypes.RoleSelect ||
+        action === OptionTypes.MentionableSelect ||
+        action === OptionTypes.ChannelSelect
+    ) {
+        const optionKey = values[0];
+        const selected = interactionData.values ?? [];
+        const opt = menu.getOption(category, page, optionKey);
+        const saveValue = opt && opt.maxValues === 1 ? selected[0] ?? null : selected;
+        await menu.save(optionKey, saveValue, { guildId, userId });
+        result = updateMessage(
+            await renderMenu(menu_key, { category, index: page, userId, guildId }),
+        );
+    }
+
+    if (result == null || result.type == null) {
+        throw new Error(`Unhandled component action "${action}"`);
+    }
+    return result;
+}
+
+module.exports = { handleComponent };

package/src/handle/modal.js

@@ -0,0 +1,231 @@
+const { decodeId, Presets } = require("../utils/customIds");
+const { EphemeralMessageFlag } = require("../utils/constants");
+const { OptionTypes, ResponseTypes } = require("../utils/types");
+const { parseModal } = require("../utils/parseModal");
+const {
+    arrayClone,
+    asObject,
+    objectDefaultsFromKeys,
+    shapeObjectListItem,
+    normalizeObjectListItems,
+} = require("../utils/helpers");
+
+function updateMessage(data) {
+    return { type: ResponseTypes.UpdateMessage, data };
+}
+
+function ephemeral(content) {
+    return {
+        type: ResponseTypes.ChannelMessageWithSource,
+        data: { flags: EphemeralMessageFlag, content },
+    };
+}
+
+function requiredContent(title) {
+    return ephemeral(`**${title}** is required.`);
+}
+
+async function handleListModal(menu, values, options, rawValue, category, page, guildId, userId) {
+    const optionKey = values[0];
+    const subAction = values[2];
+    const sub = parseInt(options.get("sub") ?? 0);
+    const menuCtx = { category, index: page, userId, guildId };
+
+    if (subAction === Presets.listItemModal) {
+        const propertyToken = values[3];
+        const objItemIndex = parseInt(options.get("item") ?? 0);
+        const option = menu.getOption(category, page, optionKey);
+        if (!option) {
+            throw new Error(`Option "${optionKey}" not found`);
+        }
+        const props = option.itemConfig.properties;
+        const objItems = normalizeObjectListItems(props, arrayClone(await menu.get(optionKey, { guildId, userId })));
+        let property;
+        const propertyIndex = parseInt(propertyToken, 10);
+        if (!Number.isNaN(propertyIndex)) {
+            property = option.itemConfig.properties[propertyIndex] ?? null;
+        } else {
+            property = option.itemConfig.properties.find(p => p.key === propertyToken) ?? null;
+        }
+        if (!property) {
+            throw new Error(`Property "${propertyToken}" not found in ObjectList "${optionKey}"`);
+        }
+        let parsedPropertyValue;
+        if (property.itemType === OptionTypes.String) {
+            parsedPropertyValue = rawValue;
+        } else if (property.itemType === OptionTypes.Number) {
+            parsedPropertyValue = parseFloat(rawValue);
+            if (Number.isNaN(parsedPropertyValue)) {
+                throw new Error(`"${rawValue}" is not a valid number`);
+            }
+        } else {
+            throw new Error(`Property type "${property.itemType}" does not support modal input`);
+        }
+        objItems[objItemIndex] = shapeObjectListItem(props, {
+            ...asObject(objItems[objItemIndex]),
+            [property.key]: parsedPropertyValue,
+        });
+        await menu.save(optionKey, objItems, { guildId, userId });
+        return updateMessage(
+            await menu.renderListObjectItemPage(optionKey, objItemIndex, { ...menuCtx, listPage: sub }),
+        );
+    }
+
+    const option = menu.getOption(category, page, optionKey);
+    if (!option) {
+        throw new Error(`Option "${optionKey}" not found`);
+    }
+    const items = arrayClone(await menu.get(optionKey, { guildId, userId }));
+    let parsedValue;
+    if (option.itemType === OptionTypes.String) {
+        parsedValue = rawValue;
+    } else if (option.itemType === OptionTypes.Number) {
+        parsedValue = parseFloat(rawValue);
+        if (Number.isNaN(parsedValue)) {
+            throw new Error(`"${rawValue}" is not a valid number`);
+        }
+    } else {
+        throw new Error(`Item type "${option.itemType}" does not support modal input`);
+    }
+    const itemIndex = values[3] != null ? parseInt(values[3], 10) : null;
+    if (subAction === Presets.edit) {
+        items[itemIndex] = parsedValue;
+    } else if (subAction === Presets.add) {
+        items.push(parsedValue);
+    } else {
+        throw new Error(`Unknown list sub-action "${subAction}"`);
+    }
+    await menu.save(optionKey, items, { guildId, userId });
+    return updateMessage(await menu.renderListPage(optionKey, sub, menuCtx));
+}
+
+async function handleObjectModal(menu, values, options, rawValue, category, page, guildId, userId) {
+    const optionKey = values[0];
+    const action = values[2];
+    const subKey = values[3];
+    const sub = parseInt(options.get("sub") ?? 0);
+    const objectPage = parseInt(options.get("op") ?? 0);
+    const menuCtx = { category, index: page, userId, guildId, objectPage };
+
+    const option = menu.getOption(category, page, optionKey);
+    if (!option) {
+        throw new Error(`Object option "${optionKey}" not found`);
+    }
+
+    if (action === Presets.subModal) {
+        const subOption = option.options.find(o => o.key === subKey);
+        if (!subOption) {
+            throw new Error(`Sub-option "${subKey}" not found`);
+        }
+        let parsedValue;
+        if (subOption.type === OptionTypes.String) {
+            if (rawValue === "") {
+                if (subOption.required) {
+                    return requiredContent(subOption.title);
+                }
+                parsedValue = null;
+            } else {
+                parsedValue = rawValue;
+            }
+        } else if (subOption.type === OptionTypes.Number) {
+            if (rawValue === "") {
+                if (subOption.required) {
+                    return requiredContent(subOption.title);
+                }
+                parsedValue = null;
+            } else {
+                parsedValue = parseFloat(rawValue);
+                if (Number.isNaN(parsedValue)) {
+                    throw new Error(`"${rawValue}" is not a valid number`);
+                }
+            }
+        } else {
+            throw new Error(`Sub-option type "${subOption.type}" does not support modal input`);
+        }
+        const baseObj = asObject(await menu.get(optionKey, { guildId, userId }));
+        const defaults = objectDefaultsFromKeys(option.options);
+        const updatedObj = Object.assign(defaults, baseObj);
+        updatedObj[subKey] = parsedValue;
+        await menu.save(optionKey, updatedObj, { guildId, userId });
+        return updateMessage(await menu.renderObjectPage(optionKey, menuCtx));
+    }
+
+    if (action === Presets.subListModal) {
+        const listAction = values[4];
+        const itemIndex = values[5] != null ? parseInt(values[5], 10) : null;
+        const subOption = option.options.find(o => o.key === subKey);
+        if (!subOption) {
+            throw new Error(`Sub-option "${subKey}" not found`);
+        }
+        const baseObj = asObject(await menu.get(optionKey, { guildId, userId }));
+        const items = arrayClone(baseObj[subKey]);
+        let parsedValue;
+        if (subOption.itemType === OptionTypes.String) {
+            parsedValue = rawValue;
+        } else if (subOption.itemType === OptionTypes.Number) {
+            parsedValue = parseFloat(rawValue);
+            if (Number.isNaN(parsedValue)) {
+                throw new Error("Invalid number");
+            }
+        } else {
+            throw new Error(`Sub-option item type "${subOption.itemType}" does not support modal input`);
+        }
+        if (listAction === Presets.edit) {
+            items[itemIndex] = parsedValue;
+        } else if (listAction === Presets.add) {
+            items.push(parsedValue);
+        } else {
+            throw new Error(`Unknown list action "${listAction}"`);
+        }
+        await menu.save(optionKey, Object.assign({}, baseObj, { [subKey]: items }), { guildId, userId });
+        return updateMessage(
+            await menu.renderObjectListPage(optionKey, subKey, sub, menuCtx),
+        );
+    }
+
+    throw new Error(`Unknown object action "${action}"`);
+}
+
+async function handleModal(interaction, menu, menu_key, renderMenu) {
+    const guildId = interaction.guildId ?? null;
+    const interactionData = interaction.data ?? {};
+    const customId = interactionData.custom_id;
+    if (!customId) {
+        throw new Error("Invalid interaction payload: missing custom_id");
+    }
+    const { options } = decodeId(customId);
+    const userId = interaction.member?.user?.id ?? interaction.user?.id ?? null;
+    const category = parseInt(options.get("cat") ?? 0);
+    const page = parseInt(options.get("page") ?? 0);
+    const menuCtx = { category, index: page, userId, guildId };
+
+    const compValues = parseModal(interactionData.components);
+    if (compValues.length <= 0) {
+        throw new Error("Invalid modal submission");
+    }
+    const { values } = decodeId(compValues[0].customId);
+    const [, optionType] = values;
+    const rawValue = compValues[0].value.trim();
+
+    if (optionType === OptionTypes.List) {
+        return handleListModal(menu, values, options, rawValue, category, page, guildId, userId);
+    }
+    if (optionType === OptionTypes.Object) {
+        return handleObjectModal(menu, values, options, rawValue, category, page, guildId, userId);
+    }
+    if (optionType === OptionTypes.String) {
+        await menu.save(values[0], rawValue, { guildId, userId });
+        return updateMessage(await renderMenu(menu_key, menuCtx));
+    }
+    if (optionType === OptionTypes.Number) {
+        const value = parseFloat(rawValue);
+        if (Number.isNaN(value)) {
+            throw new Error("Invalid number");
+        }
+        await menu.save(values[0], value, { guildId, userId });
+        return updateMessage(await renderMenu(menu_key, menuCtx));
+    }
+    throw new Error(`Option type "${optionType}" does not support modal input`);
+}
+
+module.exports = { handleModal };

package/src/index.js

@@ -0,0 +1,19 @@
+const { MenuManager } = require("./menuManager");
+const { MenuBuilder } = require("./menuBuilder");
+const { OptionTypes } = require("./utils/types");
+const { CustomIdPrefix, EphemeralMessageFlag } = require("./utils/constants");
+const { MenuStorage, MemoryMenuStorage } = require("./utils/storage");
+const { normalizeInteraction, fromEris, fromDiscordJS } = require("./utils/adapters");
+
+module.exports = {
+    MenuManager,
+    MenuBuilder,
+    OptionTypes,
+    CustomIdPrefix,
+    EphemeralMessageFlag,
+    MenuStorage,
+    MemoryMenuStorage,
+    normalizeInteraction,
+    fromEris,
+    fromDiscordJS,
+}