@kevlid/discordmenus 0.0.2

package/src/options/list.js

@@ -0,0 +1,105 @@
+const { Builder } = require("../builder");
+const { OptionTypes } = require("../utils/types");
+const { BooleanBuilder } = require("./boolean");
+
+
+class ListBuilder extends Builder {
+    constructor(itemType) {
+        super(OptionTypes.List);
+        this.itemType = itemType;
+        this.itemConfig = {};
+        this.preview = true;
+    }
+
+    setPreview(enabled) {
+        this.preview = Boolean(enabled);
+        return this;
+    }
+
+    build() {
+        const base = super.build();
+        return {
+            ...base,
+            itemType: this.itemType,
+            itemCost: this.itemCost,
+            itemConfig: this.itemConfig,
+            preview: this.preview,
+        };
+    }
+
+}
+
+
+class StringListBuilder extends ListBuilder {
+    constructor() {
+        super(OptionTypes.String);
+    }
+
+    setMinLength(length) {
+        this.itemConfig.minLength = Number(length);
+        return this;
+    }
+
+    setMaxLength(length) {
+        this.itemConfig.maxLength = Number(length);
+        return this;
+    }
+
+}
+
+
+class NumberListBuilder extends ListBuilder {
+    constructor() {
+        super(OptionTypes.Number);
+    }
+
+    setMinValue(value) {
+        this.itemConfig.minValue = Number(value);
+        return this;
+    }
+
+    setMaxValue(value) {
+        this.itemConfig.maxValue = Number(value);
+        return this;
+    }
+
+}
+
+
+class ObjectListBuilder extends ListBuilder {
+    constructor() {
+        super(OptionTypes.Object);
+        this.options = [];
+    }
+
+    addString(callback) {
+        const builder = new StringListBuilder();
+        callback(builder);
+        this.options.push(builder);
+        return this;
+    }
+
+    addNumber(callback) {
+        const builder = new NumberListBuilder();
+        callback(builder);
+        this.options.push(builder);
+        return this;
+    }
+
+    addBoolean(callback) {
+        const builder = new BooleanBuilder();
+        callback(builder);
+        this.options.push(builder);
+        return this;
+    }
+
+    build() {
+        const base = super.build();
+        base.itemConfig.properties = this.options.map(option => option.build());
+        return base;
+    }
+
+}
+
+
+module.exports = { StringListBuilder, NumberListBuilder, ObjectListBuilder };

package/src/options/number.js

@@ -0,0 +1,50 @@
+const { Builder } = require("../builder");
+const { OptionTypes } = require("../utils/types");
+
+class NumberBuilder extends Builder {
+    constructor() {
+        super(OptionTypes.Number);
+        this.preview = false;
+        this.maxValue = 2147483647;
+        this.minValue = -2147483648;
+    }
+
+    setPreview(enabled) {
+        enabled = Boolean(enabled);
+        if (typeof enabled !== "boolean") throw new TypeError("Preview must be a boolean");
+        this.preview = enabled;
+        return this;
+    }
+
+    setMaxValue(value) {
+        value = Number(value);
+        if (typeof value !== "number" || isNaN(value)) throw new TypeError("Max value must be a number");
+        if (value < -2147483648) throw new RangeError("Max value cannot be less than -2147483648");
+        if (value > 2147483647) throw new RangeError("Max value cannot exceed 2147483647");
+        this.maxValue = value;
+        return this;
+    }
+
+    setMinValue(value) {
+        value = Number(value);
+        if (typeof value !== "number" || isNaN(value)) throw new TypeError("Min value must be a number");
+        if (value < -2147483648) throw new RangeError("Min value cannot be less than -2147483648");
+        if (value > 2147483647) throw new RangeError("Min value cannot exceed 2147483647");
+        this.minValue = value;
+        return this;
+    }
+
+    build() {
+        const base = super.build();
+        return {
+            ...base,
+            preview: this.preview,
+            maxValue: this.maxValue,
+            minValue: this.minValue,
+        };
+    }
+}
+
+module.exports = {
+    NumberBuilder
+}

package/src/options/object.js

@@ -0,0 +1,74 @@
+const { Builder } = require("../builder");
+const { OptionTypes } = require("../utils/types");
+const { StringBuilder } = require("./string");
+const { NumberBuilder } = require("./number");
+const { BooleanBuilder } = require("./boolean");
+const { StringListBuilder, NumberListBuilder } = require("./list");
+
+class ObjectBuilder extends Builder {
+    constructor() {
+        super(OptionTypes.Object);
+        this.preview = false;
+        this.options = [];
+    }
+
+    setPreview(enabled) {
+        enabled = Boolean(enabled);
+        this.preview = enabled;
+        return this;
+    }
+
+    #addOptions(options) {
+        for (const builder of options) {
+            this.options.push(builder);
+        }
+    }
+
+    addString(callback) {
+        const builder = new StringBuilder();
+        callback(builder);
+        this.#addOptions([builder]);
+        return this;
+    }
+
+    addNumber(callback) {
+        const builder = new NumberBuilder();
+        callback(builder);
+        this.#addOptions([builder]);
+        return this;
+    }
+
+    addBoolean(callback) {
+        const builder = new BooleanBuilder();
+        callback(builder);
+        this.#addOptions([builder]);
+        return this;
+    }
+
+    addStringList(callback) {
+        const builder = new StringListBuilder();
+        callback(builder);
+        this.#addOptions([builder]);
+        return this;
+    }
+
+    addNumberList(callback) {
+        const builder = new NumberListBuilder();
+        callback(builder);
+        this.#addOptions([builder]);
+        return this;
+    }
+
+    build() {
+        const base = super.build();
+        return {
+            ...base,
+            preview: this.preview,
+            options: this.options.map(option => option.build()),
+        };
+    }
+}
+
+module.exports = {
+    ObjectBuilder,
+};

package/src/options/selectMenu.js

@@ -0,0 +1,132 @@
+const { Builder } = require("../builder");
+const { OptionTypes } = require("../utils/types");
+const { ComponentTypes } = require("../render/types");
+
+class SelectMenuBuilder extends Builder {
+    constructor(optionType, selectComponentType) {
+        super(optionType);
+        this.selectType = selectComponentType;
+        this.placeholder = null;
+        this.minValues = 1;
+        this.maxValues = 1;
+    }
+
+    setPlaceholder(text) {
+        this.placeholder = String(text);
+        return this;
+    }
+
+    setMinValues(n) {
+        this.minValues = Number(n);
+        return this;
+    }
+
+    setMaxValues(n) {
+        this.maxValues = Number(n);
+        return this;
+    }
+
+    build() {
+        const base = super.build();
+        return {
+            ...base,
+            selectType: this.selectType,
+            placeholder: this.placeholder,
+            minValues: this.minValues,
+            maxValues: this.maxValues,
+        };
+    }
+}
+
+class StringSelectBuilder extends SelectMenuBuilder {
+    constructor() {
+        super(OptionTypes.StringSelect, ComponentTypes.StringSelect);
+        this.choices = [];
+    }
+
+    addChoice(label, value, callback) {
+        const builder = new StringSelectChoiceBuilder(label, value);
+        if (callback) {
+            callback(builder);
+        }
+        this.choices.push(builder);
+        return this;
+    }
+
+    build() {
+        const base = super.build();
+        return {
+            ...base,
+            choices: this.choices.map(c => c.build()),
+        };
+    }
+}
+
+class StringSelectChoiceBuilder {
+    constructor(label, value) {
+        this.label = label;
+        this.value = value;
+        this.description = null;
+        this.isDefault = false;
+    }
+
+    setDescription(desc) {
+        this.description = String(desc);
+        return this;
+    }
+
+    build() {
+        return {
+            label: this.label,
+            value: this.value,
+            description: this.description,
+            default: this.isDefault,
+        };
+    }
+}
+
+class UserSelectBuilder extends SelectMenuBuilder {
+    constructor() {
+        super(OptionTypes.UserSelect, ComponentTypes.UserSelect);
+    }
+}
+
+class RoleSelectBuilder extends SelectMenuBuilder {
+    constructor() {
+        super(OptionTypes.RoleSelect, ComponentTypes.RoleSelect);
+    }
+}
+
+class MentionableSelectBuilder extends SelectMenuBuilder {
+    constructor() {
+        super(OptionTypes.MentionableSelect, ComponentTypes.MentionableSelect);
+    }
+}
+
+class ChannelSelectBuilder extends SelectMenuBuilder {
+    constructor() {
+        super(OptionTypes.ChannelSelect, ComponentTypes.ChannelSelect);
+        this.channelTypes = [];
+    }
+
+    addChannelType(channelType) {
+        this.channelTypes.push(Number(channelType));
+        return this;
+    }
+
+    build() {
+        const base = super.build();
+        return {
+            ...base,
+            channelTypes: this.channelTypes,
+        };
+    }
+}
+
+module.exports = {
+    StringSelectBuilder,
+    UserSelectBuilder,
+    RoleSelectBuilder,
+    MentionableSelectBuilder,
+    ChannelSelectBuilder,
+};

package/src/options/string.js

@@ -0,0 +1,50 @@
+const { Builder } = require("../builder");
+const { OptionTypes } = require("../utils/types");
+
+class StringBuilder extends Builder {
+    constructor() {
+        super(OptionTypes.String);
+        this.preview = false;
+        this.maxLength = 4000;
+        this.minLength = 0;
+    }
+
+    setPreview(enabled) {
+        enabled = Boolean(enabled);
+        if (typeof enabled !== "boolean") throw new TypeError("Preview must be a boolean");
+        this.preview = enabled;
+        return this;
+    }
+
+    setMaxLength(length) {
+        length = Number(length);
+        if (typeof length !== "number" || isNaN(length)) throw new TypeError("Max length must be a number");
+        if (length < 1) throw new RangeError("Max length must be at least 1");
+        if (length > 4000) throw new RangeError("Max length cannot exceed 4000");
+        this.maxLength = length;
+        return this;
+    }
+
+    setMinLength(length) {
+        length = Number(length);
+        if (typeof length !== "number" || isNaN(length)) throw new TypeError("Min length must be a number");
+        if (length < 0) throw new RangeError("Min length cannot be negative");
+        if (length > 4000) throw new RangeError("Min length cannot exceed 4000");
+        this.minLength = length;
+        return this;
+    }
+
+    build() {
+        const base = super.build();
+        return {
+            ...base,
+            preview: this.preview,
+            maxLength: this.maxLength,
+            minLength: this.minLength,
+        };
+    }
+}
+
+module.exports = {
+    StringBuilder
+}