@kevlid/discordmenus 0.0.2

package/src/utils/adapters.js

@@ -0,0 +1,98 @@
+function getPermissions(interaction) {
+    const raw = interaction?.member?.permissions ?? interaction?.member?.permission ?? interaction?.memberPermissions ?? null;
+    if (raw == null) {
+        return "0";
+    }
+    if (typeof raw === "object" && raw.allow != null) {
+        return String(raw.allow);
+    }
+    if (typeof raw.valueOf === "function") {
+        return String(raw.valueOf());
+    }
+    return String(raw);
+}
+
+function normalizeInteraction(interaction) {
+    const source = typeof interaction?.toJSON === "function" ? interaction.toJSON() : interaction ?? {};
+
+    const userId =
+        source.member?.user?.id
+        ?? source.user?.id
+        ?? interaction?.member?.user?.id
+        ?? interaction?.user?.id
+        ?? null;
+
+    let customId =
+        source.data?.custom_id
+        ?? source.data?.customID
+        ?? source.custom_id
+        ?? source.customId
+        ?? interaction?.data?.custom_id
+        ?? interaction?.data?.customID
+        ?? interaction?.custom_id
+        ?? interaction?.customId
+        ?? null;
+
+    if (customId == null && typeof source.id === "string" && source.id.length > 0) {
+        customId = source.id;
+    }
+
+    let values = source.data?.values ?? source.values ?? interaction?.data?.values ?? interaction?.values ?? [];
+    if (!Array.isArray(values)) {
+        values = [];
+    }
+
+    let components =
+        source.data?.components
+        ?? source.components
+        ?? source.fields?.components
+        ?? interaction?.data?.components
+        ?? interaction?.components
+        ?? interaction?.fields?.components
+        ?? [];
+    if (!Array.isArray(components)) {
+        components = [];
+    }
+
+    const normalized = {
+        type: source.type ?? interaction?.type ?? null,
+        guildId:
+            source.guildId
+            ?? source.guild_id
+            ?? source.guildID
+            ?? interaction?.guildId
+            ?? interaction?.guild_id
+            ?? interaction?.guildID
+            ?? null,
+        member: null,
+        user: null,
+        data: {
+            custom_id: customId,
+            values,
+            components,
+        },
+    };
+
+    if (userId != null) {
+        normalized.user = { id: userId };
+    }
+
+    if (source.member != null || interaction?.member != null) {
+        normalized.member = {
+            user: { id: userId },
+            permissions: getPermissions(interaction),
+        };
+    }
+
+    return normalized;
+}
+
+function fromEris(interaction) {
+    return normalizeInteraction(interaction);
+}
+
+function fromDiscordJS(interaction) {
+    return normalizeInteraction(interaction);
+}
+
+module.exports = { normalizeInteraction, fromEris, fromDiscordJS };

package/src/utils/componentsValidate.js

@@ -0,0 +1,23 @@
+const { MaxComponents } = require("./constants");
+
+function validateComponents(components, max = MaxComponents) {
+    if (!Array.isArray(components)) {
+        throw new Error("components must be an array");
+    }
+    if (components.length > max) {
+        throw new Error(`Too many components: ${components.length} > ${max}`);
+    }
+    for (const comp of components) {
+        if (typeof comp !== "object" || comp == null) {
+            throw new Error("Component is not an object");
+        }
+        if (!("type" in comp)) {
+            throw new Error("Component missing type field");
+        }
+        if (comp.components) {
+            validateComponents(comp.components, max);
+        }
+    }
+}
+
+module.exports = { validateComponents };

package/src/utils/constants.js

@@ -0,0 +1,11 @@
+module.exports = {
+    CustomIdPrefix: "dm",
+    ComponentsV2MessageFlags: 32768,
+    EphemeralMessageFlag: 64,
+    MaxComponents: 40,
+    PageRenderOverhead: 9,
+    OptionRenderCost: 4,
+    ObjectPageOverhead: 8,
+    ObjectListPageOverhead: 8,
+    ObjectListItemCost: 5,
+};

package/src/utils/customIds.js

@@ -0,0 +1,67 @@
+const { encodeCustomId, decodeCustomId, encodeToken, decodeToken } = require("@kevlid/customids");
+const { CustomIdPrefix } = require("./constants");
+
+const Presets = {
+    userId: "uid",
+    previousPage: "pp",
+    nextPage: "np",
+    previousCategory: "pc",
+    nextCategory: "nc",
+    nav: "nav",
+    view: "view",
+    done: "done",
+    add: "add",
+    edit: "edit",
+    delete: "delete",
+    modal: "modal",
+    subModal: "sub_modal",
+    subBoolean: "sub_boolean",
+    subList: "sub_list",
+    subListModal: "sub_list_modal",
+    listItemView: "iv",
+    listItemDone: "id",
+    listItemField: "if",
+    listItemModal: "im",
+    listItemBoolToggle: "it",
+    navSpacer: "ns",
+};
+
+function encodeId(menuKey, values = [], options = {}) {
+    let optionString = "";
+    if (Object.keys(options).length > 0) {
+        optionString += "|";
+    }
+    for (const [key, value] of Object.entries(options)) {
+        if (key.length > 9) throw new Error("Option keys must be at most 9 characters long");
+        optionString += `${key.length}${key}${encodeToken(value)};`;
+    }
+    let customId = CustomIdPrefix + encodeCustomId([menuKey, ...values]) + optionString;
+    if (customId.length > 100) {
+        throw new Error(`Encoded custom ID is too long (${customId.length} characters). Consider using shorter option keys or fewer values.`);
+    }
+    return customId;
+}
+
+function decodeId(id) {
+    const raw = id.slice(CustomIdPrefix.length);
+    const options = new Map();
+    const [parts, optionString] = raw.split("|");
+    const { values: decoded } = decodeCustomId(parts);
+    const [menu_key, ...values] = decoded;
+    if (optionString) {
+        const optionParts = optionString.split(";").filter(Boolean);
+        for (const part of optionParts) {
+            const keyLength = parseInt(part[0]);
+            const key = part.slice(1, 1 + keyLength);
+            const value = decodeToken(part.slice(1 + keyLength));
+            options.set(key, value);
+        }
+    }
+    return { menu_key, values, options };
+}
+
+module.exports = {
+    encodeId,
+    decodeId,
+    Presets,
+};

package/src/utils/formatKey.js

@@ -0,0 +1 @@
+function formatKey(key) {
    if (typeof key !== "string") throw new TypeError("Key must be a string");
    return key.toLowerCase().replace(" ", "_");
    formatKey

package/src/utils/helpers.js

@@ -0,0 +1,100 @@
+const { OptionTypes } = require("./types");
+
+function arrayClone(v) {
+    return Array.isArray(v) ? [...v] : [];
+}
+
+function asObject(v) {
+    return v != null && typeof v === "object" ? v : {};
+}
+
+function objectDefaultsFromKeys(options) {
+    const out = {};
+    for (const opt of options || []) {
+        out[opt.key] = null;
+    }
+    return out;
+}
+
+function objectListPropertyKey(option, token) {
+    if (!option || option.itemType !== OptionTypes.Object) {
+        return token;
+    }
+    const idx = parseInt(token, 10);
+    const props = option.itemConfig?.properties;
+    if (!Number.isNaN(idx) && Array.isArray(props) && props[idx]) {
+        return props[idx].key;
+    }
+    return token;
+}
+
+function objectListItemFailsRequired(option, currentItem) {
+    const props = option?.itemConfig?.properties;
+    if (!Array.isArray(props)) {
+        return false;
+    }
+    for (const property of props) {
+        if (!property.required) {
+            continue;
+        }
+        let fieldValue;
+        if (currentItem != null && typeof currentItem === "object") {
+            fieldValue = currentItem[property.key];
+        } else {
+            fieldValue = null;
+        }
+        if (property.type === OptionTypes.String) {
+            if (fieldValue == null || String(fieldValue).trim() === "") {
+                return true;
+            }
+        } else if (property.type === OptionTypes.Number) {
+            if (fieldValue == null || Number.isNaN(Number(fieldValue))) {
+                return true;
+            }
+        } else if (property.type === OptionTypes.Boolean) {
+            if (fieldValue == null) {
+                return true;
+            }
+        } else if (fieldValue == null) {
+            return true;
+        }
+    }
+    return false;
+}
+
+function listJumpSize(length) {
+    return Math.min(10, Math.max(1, Math.ceil(length * 0.1)));
+}
+
+function shapeObjectListItem(properties, raw) {
+    const s = raw != null && typeof raw === "object" ? raw : {};
+    const o = {};
+    for (const p of properties || []) {
+        o[p.key] = Object.prototype.hasOwnProperty.call(s, p.key) ? s[p.key] : null;
+    }
+    return o;
+}
+
+function normalizeObjectListItems(properties, items) {
+    if (!Array.isArray(items)) {
+        return [];
+    }
+    return items.map(item => shapeObjectListItem(properties, item));
+}
+
+function objectListItemsNeedReshape(properties, items) {
+    const norm = normalizeObjectListItems(properties, items);
+    return JSON.stringify(items) !== JSON.stringify(norm);
+}
+
+module.exports = {
+    arrayClone,
+    asObject,
+    objectDefaultsFromKeys,
+    objectListPropertyKey,
+    objectListItemFailsRequired,
+    listJumpSize,
+    shapeObjectListItem,
+    normalizeObjectListItems,
+    objectListItemsNeedReshape,
+};

package/src/utils/parseModal.js

@@ -0,0 +1 @@
+const { ComponentTypes } = require("../render/types");
    const results = [];
    if (!Array.isArray(components)) {
        return results;
    }
    for (const row of components) {
        let inputs = [];
        if (row.type === ComponentTypes.ActionRow) {
            if (Array.isArray(row.components)) {
                inputs = row.components;
            }
        } else if (row.type === ComponentTypes.Label) {
            if (row.component != null) {
                inputs = [row.component];
            }
        }
        for (const input of inputs) {
            if (input == null) {
                continue;
            }
            const customId = input.custom_id ?? input.customId;
            if (customId == null) {
                continue;
            }
            results.push({
                customId: String(customId),
                type: input.type,
                value: input.value ?? null,
            });
        }
    }
    return results;

package/src/utils/storage.js

@@ -0,0 +1,131 @@
+class MenuStorage {
+    constructor({ cache = false, cacheTTL = 60000, cacheMaxSize = 500 } = {}) {
+        this.cacheEnabled = cache;
+        this.cacheTTL = cacheTTL;
+        this.cacheMaxSize = cacheMaxSize;
+        this.cache = new Map();
+
+        if (cache) {
+            setInterval(() => {
+                const now = Date.now();
+                for (const [k, entry] of this.cache.entries()) {
+                    if (now - entry.ts > this.cacheTTL) {
+                        this.cache.delete(k);
+                    }
+                }
+            }, cacheTTL);
+        }
+    }
+
+    cacheKey(key, guildId) {
+        if (guildId) {
+            return `${guildId}:${key}`;
+        }
+        return key;
+    }
+
+    cacheGet(key, guildId) {
+        if (!this.cacheEnabled) {
+            return undefined;
+        }
+        const ck = this.cacheKey(key, guildId);
+        const entry = this.cache.get(ck);
+        if (!entry) {
+            return undefined;
+        }
+        if (Date.now() - entry.ts > this.cacheTTL) {
+            this.cache.delete(ck);
+            return undefined;
+        }
+        return entry.value;
+    }
+
+    cacheSet(key, value, guildId) {
+        if (!this.cacheEnabled) {
+            return;
+        }
+        if (this.cache.size >= this.cacheMaxSize) {
+            this.cache.delete(this.cache.keys().next().value);
+        }
+        this.cache.set(this.cacheKey(key, guildId), { value, ts: Date.now() });
+    }
+
+    cacheDelete(key, guildId) {
+        if (!this.cacheEnabled) {
+            return;
+        }
+        this.cache.delete(this.cacheKey(key, guildId));
+    }
+
+    cacheClear(guildId) {
+        if (!this.cacheEnabled) {
+            return;
+        }
+        if (guildId) {
+            const prefix = `${guildId}:`;
+            for (const k of this.cache.keys()) {
+                if (k.startsWith(prefix)) {
+                    this.cache.delete(k);
+                }
+            }
+        } else {
+            this.cache.clear();
+        }
+    }
+
+    async get(key, ctx = {}) {
+        throw new Error("MenuStorage: get() must be implemented");
+    }
+
+    async save(key, value, ctx = {}) {
+        throw new Error("MenuStorage: save() must be implemented");
+    }
+
+    handler() {
+        return {
+            get: async (key, ctx) => {
+                const guildId = ctx?.guildId ?? null;
+                const cached = this.cacheGet(key, guildId);
+                if (cached !== undefined) {
+                    return cached;
+                }
+                const result = await this.get(key, ctx);
+                this.cacheSet(key, result, guildId);
+                return result;
+            },
+            save: async (key, value, ctx) => {
+                const guildId = ctx?.guildId ?? null;
+                this.cacheDelete(key, guildId);
+                return this.save(key, value, ctx);
+            },
+        };
+    }
+}
+
+class MemoryMenuStorage extends MenuStorage {
+    constructor(opts = {}) {
+        super(opts);
+        this.data = new Map();
+    }
+
+    storeKey(key, guildId) {
+        if (guildId) {
+            return `${guildId}:${key}`;
+        }
+        return key;
+    }
+
+    async get(key, { guildId } = {}) {
+        const stored = this.data.get(this.storeKey(key, guildId));
+        if (stored === undefined) {
+            return null;
+        }
+        return stored;
+    }
+
+    async save(key, value, { guildId } = {}) {
+        this.data.set(this.storeKey(key, guildId), value);
+    }
+}
+
+module.exports = { MenuStorage, MemoryMenuStorage };

package/src/utils/types.js

@@ -0,0 +1,34 @@
+const OptionTypes = {
+    Menu: "menu",
+    Category: "category",
+    String: "string",
+    Number: "number",
+    Boolean: "boolean",
+    List: "list",
+    Object: "object",
+    StringSelect: "string_select",
+    UserSelect: "user_select",
+    RoleSelect: "role_select",
+    MentionableSelect: "mentionable_select",
+    ChannelSelect: "channel_select",
+};
+
+const InteractionTypes = {
+    ApplicationCommand: 2,
+    MessageComponent: 3,
+    ModalSubmit: 5,
+};
+
+const ResponseTypes = {
+    ChannelMessageWithSource: 4,
+    DeferredChannelMessageWithSource: 5,
+    DeferredUpdateMessage: 6,
+    UpdateMessage: 7,
+    Modal: 9,
+};
+
+module.exports = {
+    OptionTypes,
+    InteractionTypes,
+    ResponseTypes,
+};