@discordeno/utils 19.0.0 → 20.0.0-next.8482859

package/dist/cjs/builders/embeds.cjs

@@ -0,0 +1,291 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "EmbedsBuilder", {
+    enumerable: true,
+    get: function() {
+        return EmbedsBuilder;
+    }
+});
+let EmbedsBuilder = class EmbedsBuilder extends Array {
+    #currentEmbedIndex;
+    /**
+   * Adds a new field to the embed fields array.
+   *
+   * @param {string} name - Field name
+   * @param {string} value - Field value
+   * @param {?boolean} [inline=false] - Field should be inline or not.
+   * @returns {EmbedsBuilder}
+   */ addField(name, value, inline) {
+        if (this.#currentEmbed.fields === undefined) {
+            this.#currentEmbed.fields = [];
+        }
+        this.#currentEmbed.fields.push({
+            name,
+            value,
+            inline
+        });
+        return this;
+    }
+    /**
+   * Creates a blank embed.
+   *
+   * @returns {EmbedsBuilder}
+   */ newEmbed() {
+        if (this.length >= 10) {
+            throw new Error('Maximum embed count exceeded. You can not have more than 10 embeds.');
+        }
+        this.push({});
+        this.setCurrentEmbed();
+        return this;
+    }
+    /**
+   * Set the current embed author.
+   *
+   * @param {string} name - Name of the author
+   * @param {?Omit<DiscordEmbedAuthor, 'name'>} [options] - Extra author options
+   * @returns {EmbedsBuilder}
+   */ setAuthor(name, options) {
+        this.#currentEmbed.author = {
+            ...this.#currentEmbed.author,
+            ...options,
+            name
+        };
+        return this;
+    }
+    /**
+   * Set the color on the side of the current embed.
+   *
+   * @param {(number | string)} color - The color, in base16 or hex color code
+   * @returns {EmbedsBuilder}
+   */ setColor(color) {
+        if (typeof color === 'string') {
+            const convertedValue = parseInt(color.replace('#', ''), 16);
+            color = Number.isNaN(convertedValue) ? 0 : convertedValue;
+        }
+        this.#currentEmbed.color = color;
+        return this;
+    }
+    /**
+   * Set the current embed to a different index.
+   *
+   * WARNING: Only use this method if you know what you're doing. Make sure to set it back to the latest when you're done.
+   *
+   * @param {?number} [index] - The index of the embed in the EmbedsBuilder array
+   * @returns {EmbedsBuilder}
+   */ setCurrentEmbed(index) {
+        if (index === undefined) {
+            this.#currentEmbedIndex = this.length - 1;
+            return this;
+        }
+        if (index >= this.length || index < 0) {
+            throw new Error('Can not set the current embed to a index out of bounds.');
+        }
+        this.#currentEmbedIndex = index;
+        return this;
+    }
+    /**
+   * Set the description of the current embed.
+   *
+   * @param {string} description - Description
+   * @returns {EmbedsBuilder}
+   */ setDescription(description) {
+        this.#currentEmbed.description = description;
+        return this;
+    }
+    /**
+   * Overwrite all fields on the current embed.
+   *
+   * @param {DiscordEmbedField[]} fields
+   * @returns {EmbedsBuilder}
+   */ setFields(fields) {
+        this.#currentEmbed.fields = fields;
+        return this;
+    }
+    /**
+   * Set the footer in the current embed.
+   *
+   * @param {string} text - The text to display in the footer
+   * @param {?Omit<DiscordEmbedFooter, 'text'>} [options]
+   * @returns {EmbedsBuilder}
+   */ setFooter(text, options) {
+        this.#currentEmbed.footer = {
+            ...this.#currentEmbed.footer,
+            ...options,
+            text
+        };
+        return this;
+    }
+    /**
+   * Set the image in the current embed.
+   *
+   * @param {string} url - URL of the image
+   * @param {?Omit<DiscordEmbedImage, 'url'>} [options]
+   * @returns {EmbedsBuilder}
+   */ setImage(url, options) {
+        this.#currentEmbed.image = {
+            ...this.#currentEmbed.image,
+            ...options,
+            url
+        };
+        return this;
+    }
+    /**
+   * Set the provider of the current embed.
+   *
+   * @param {string} name
+   * @param {?string} [url]
+   * @returns {EmbedsBuilder}
+   */ setProvider(name, url) {
+        this.#currentEmbed.provider = {
+            name,
+            url
+        };
+        return this;
+    }
+    /**
+   * Set the color of the current embed to a random value.
+   *
+   * @returns {EmbedsBuilder}
+   */ setRandomColor() {
+        return this.setColor(Math.floor(Math.random() * (0xffffff + 1)));
+    }
+    /**
+   * Set the title of the current embed.
+   *
+   * @param {string} title
+   * @param {?string} [url]
+   * @returns {EmbedsBuilder}
+   */ setTitle(title, url) {
+        this.#currentEmbed.title = title;
+        if (url) {
+            this.setUrl(url);
+        }
+        return this;
+    }
+    /**
+   * Set the timestamp of the current embed.
+   *
+   * @param {?(string | number | Date)} [timestamp]
+   * @returns {EmbedsBuilder}
+   */ setTimestamp(timestamp) {
+        this.#currentEmbed.timestamp = new Date(timestamp).toISOString();
+        return this;
+    }
+    /**
+   * Set the thumbnail of the current embed.
+   *
+   * @param {string} url - URL of the image
+   * @param {?Omit<DiscordEmbedThumbnail, 'url'>} [options]
+   * @returns {EmbedsBuilder}
+   */ setThumbnail(url, options) {
+        this.#currentEmbed.thumbnail = {
+            ...this.#currentEmbed.thumbnail,
+            ...options,
+            url
+        };
+        return this;
+    }
+    /**
+   * Set the URL of the current embed title.
+   *
+   * @param {string} url
+   * @returns {EmbedsBuilder}
+   */ setUrl(url) {
+        this.#currentEmbed.url = url;
+        return this;
+    }
+    /**
+   * Set the video of the current embed.
+   *
+   * @param {string} url
+   * @param {?Omit<DiscordEmbedVideo, 'url'>} [options]
+   * @returns {EmbedsBuilder}
+   */ setVideo(url, options) {
+        this.#currentEmbed.video = {
+            ...this.#currentEmbed.video,
+            ...options,
+            url
+        };
+        return this;
+    }
+    /**
+   * Validate all embeds available against current known Discord limits to help prevent bad requests.
+   *
+   * @returns {EmbedsBuilder}
+   */ validate() {
+        let totalCharacters = 0;
+        if (this.length > 10) {
+            throw new Error('You can not have more than 10 embeds on a single message.');
+        }
+        this.forEach(({ author, description, fields, footer, title }, index)=>{
+            if (title) {
+                const trimmedTitle = title.trim();
+                if (trimmedTitle.length > 256) {
+                    throw new Error(`Title of embed ${index} can not be longer than 256 characters.`);
+                }
+                totalCharacters += trimmedTitle.length;
+            }
+            if (description) {
+                const trimmedDescription = description.trim();
+                if (trimmedDescription.length > 4096) {
+                    throw new Error(`Description of embed ${index} can not be longer than 4096 characters.`);
+                }
+                totalCharacters += trimmedDescription.length;
+            }
+            if (fields) {
+                if (fields.length > 25) {
+                    throw new Error(`embed ${index} can not have more than 25 fields.`);
+                }
+                fields.forEach(({ name, value }, fieldIndex)=>{
+                    const trimmedName = name.trim();
+                    const trimmedValue = value.trim();
+                    if (trimmedName.length > 256) {
+                        throw new Error(`Name of field ${fieldIndex} on embed ${index} can not be longer than 256 characters.`);
+                    }
+                    if (trimmedValue.length > 4096) {
+                        throw new Error(`Value of field ${fieldIndex} on embed ${index} can not be longer than 1024 characters.`);
+                    }
+                    totalCharacters += trimmedName.length;
+                    totalCharacters += trimmedValue.length;
+                });
+            }
+            if (footer) {
+                const trimmedFooterText = footer.text.trim();
+                if (trimmedFooterText.length > 2048) {
+                    throw new Error(`Footer text of embed ${index} can not be longer than 2048 characters.`);
+                }
+                totalCharacters += trimmedFooterText.length;
+            }
+            if (author) {
+                const trimmedAuthorName = author.name.trim();
+                if (trimmedAuthorName.length > 256) {
+                    throw new Error(`Author name of embed ${index} can not be longer than 256 characters.`);
+                }
+                totalCharacters += trimmedAuthorName.length;
+            }
+        });
+        if (totalCharacters > 6000) {
+            throw new Error('Total character length of all embeds can not exceed 6000 characters.');
+        }
+        return this;
+    }
+    /**
+   * Returns the current embed.
+   *
+   * @readonly
+   * @type {DiscordEmbed}
+   */ get #currentEmbed() {
+        if (this.length === 0) {
+            this.newEmbed();
+            this.setCurrentEmbed();
+        }
+        return this[this.#currentEmbedIndex];
+    }
+    constructor(...args){
+        super(...args), this.#currentEmbedIndex = 0;
+    }
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/builders/embeds.ts"],"sourcesContent":["import type {\n  DiscordEmbed,\n  DiscordEmbedAuthor,\n  DiscordEmbedField,\n  DiscordEmbedFooter,\n  DiscordEmbedImage,\n  DiscordEmbedThumbnail,\n  DiscordEmbedVideo,\n} from '@discordeno/types'\n\n/**\n * A builder to help create Discord embeds.\n *\n * @example\n * const embeds = new EmbedBuilder()\n *  .setTitle('My Embed')\n *  .setDescription('This is my new embed')\n *  .newEmbed()\n *  .setTitle('My Second Embed')\n */\nexport class EmbedsBuilder extends Array<DiscordEmbed> {\n  #currentEmbedIndex: number = 0\n\n  /**\n   * Adds a new field to the embed fields array.\n   *\n   * @param {string} name - Field name\n   * @param {string} value - Field value\n   * @param {?boolean} [inline=false] - Field should be inline or not.\n   * @returns {EmbedsBuilder}\n   */\n  addField(name: string, value: string, inline?: boolean): this {\n    if (this.#currentEmbed.fields === undefined) {\n      this.#currentEmbed.fields = []\n    }\n\n    this.#currentEmbed.fields.push({\n      name,\n      value,\n      inline,\n    })\n\n    return this\n  }\n\n  /**\n   * Creates a blank embed.\n   *\n   * @returns {EmbedsBuilder}\n   */\n  newEmbed(): this {\n    if (this.length >= 10) {\n      throw new Error('Maximum embed count exceeded. You can not have more than 10 embeds.')\n    }\n\n    this.push({})\n    this.setCurrentEmbed()\n\n    return this\n  }\n\n  /**\n   * Set the current embed author.\n   *\n   * @param {string} name - Name of the author\n   * @param {?Omit<DiscordEmbedAuthor, 'name'>} [options] - Extra author options\n   * @returns {EmbedsBuilder}\n   */\n  setAuthor(name: string, options?: Omit<DiscordEmbedAuthor, 'name'>): this {\n    this.#currentEmbed.author = {\n      ...this.#currentEmbed.author,\n      ...options,\n      name,\n    }\n\n    return this\n  }\n\n  /**\n   * Set the color on the side of the current embed.\n   *\n   * @param {(number | string)} color - The color, in base16 or hex color code\n   * @returns {EmbedsBuilder}\n   */\n  setColor(color: number | string): this {\n    if (typeof color === 'string') {\n      const convertedValue = parseInt(color.replace('#', ''), 16)\n      color = Number.isNaN(convertedValue) ? 0 : convertedValue\n    }\n\n    this.#currentEmbed.color = color\n\n    return this\n  }\n\n  /**\n   * Set the current embed to a different index.\n   *\n   * WARNING: Only use this method if you know what you're doing. Make sure to set it back to the latest when you're done.\n   *\n   * @param {?number} [index] - The index of the embed in the EmbedsBuilder array\n   * @returns {EmbedsBuilder}\n   */\n  setCurrentEmbed(index?: number): this {\n    if (index === undefined) {\n      this.#currentEmbedIndex = this.length - 1\n\n      return this\n    }\n\n    if (index >= this.length || index < 0) {\n      throw new Error('Can not set the current embed to a index out of bounds.')\n    }\n\n    this.#currentEmbedIndex = index\n\n    return this\n  }\n\n  /**\n   * Set the description of the current embed.\n   *\n   * @param {string} description - Description\n   * @returns {EmbedsBuilder}\n   */\n  setDescription(description: string): this {\n    this.#currentEmbed.description = description\n\n    return this\n  }\n\n  /**\n   * Overwrite all fields on the current embed.\n   *\n   * @param {DiscordEmbedField[]} fields\n   * @returns {EmbedsBuilder}\n   */\n  setFields(fields: DiscordEmbedField[]): this {\n    this.#currentEmbed.fields = fields\n\n    return this\n  }\n\n  /**\n   * Set the footer in the current embed.\n   *\n   * @param {string} text - The text to display in the footer\n   * @param {?Omit<DiscordEmbedFooter, 'text'>} [options]\n   * @returns {EmbedsBuilder}\n   */\n  setFooter(text: string, options?: Omit<DiscordEmbedFooter, 'text'>): this {\n    this.#currentEmbed.footer = {\n      ...this.#currentEmbed.footer,\n      ...options,\n      text,\n    }\n\n    return this\n  }\n\n  /**\n   * Set the image in the current embed.\n   *\n   * @param {string} url - URL of the image\n   * @param {?Omit<DiscordEmbedImage, 'url'>} [options]\n   * @returns {EmbedsBuilder}\n   */\n  setImage(url: string, options?: Omit<DiscordEmbedImage, 'url'>): this {\n    this.#currentEmbed.image = {\n      ...this.#currentEmbed.image,\n      ...options,\n      url,\n    }\n\n    return this\n  }\n\n  /**\n   * Set the provider of the current embed.\n   *\n   * @param {string} name\n   * @param {?string} [url]\n   * @returns {EmbedsBuilder}\n   */\n  setProvider(name: string, url?: string): this {\n    this.#currentEmbed.provider = {\n      name,\n      url,\n    }\n\n    return this\n  }\n\n  /**\n   * Set the color of the current embed to a random value.\n   *\n   * @returns {EmbedsBuilder}\n   */\n  setRandomColor(): this {\n    return this.setColor(Math.floor(Math.random() * (0xffffff + 1)))\n  }\n\n  /**\n   * Set the title of the current embed.\n   *\n   * @param {string} title\n   * @param {?string} [url]\n   * @returns {EmbedsBuilder}\n   */\n  setTitle(title: string, url?: string): this {\n    this.#currentEmbed.title = title\n\n    if (url) {\n      this.setUrl(url)\n    }\n\n    return this\n  }\n\n  /**\n   * Set the timestamp of the current embed.\n   *\n   * @param {?(string | number | Date)} [timestamp]\n   * @returns {EmbedsBuilder}\n   */\n  setTimestamp(timestamp?: string | number | Date): this {\n    this.#currentEmbed.timestamp = new Date(timestamp!).toISOString()\n\n    return this\n  }\n\n  /**\n   * Set the thumbnail of the current embed.\n   *\n   * @param {string} url - URL of the image\n   * @param {?Omit<DiscordEmbedThumbnail, 'url'>} [options]\n   * @returns {EmbedsBuilder}\n   */\n  setThumbnail(url: string, options?: Omit<DiscordEmbedThumbnail, 'url'>): this {\n    this.#currentEmbed.thumbnail = {\n      ...this.#currentEmbed.thumbnail,\n      ...options,\n      url,\n    }\n\n    return this\n  }\n\n  /**\n   * Set the URL of the current embed title.\n   *\n   * @param {string} url\n   * @returns {EmbedsBuilder}\n   */\n  setUrl(url: string): this {\n    this.#currentEmbed.url = url\n\n    return this\n  }\n\n  /**\n   * Set the video of the current embed.\n   *\n   * @param {string} url\n   * @param {?Omit<DiscordEmbedVideo, 'url'>} [options]\n   * @returns {EmbedsBuilder}\n   */\n  setVideo(url: string, options?: Omit<DiscordEmbedVideo, 'url'>): this {\n    this.#currentEmbed.video = {\n      ...this.#currentEmbed.video,\n      ...options,\n      url,\n    }\n\n    return this\n  }\n\n  /**\n   * Validate all embeds available against current known Discord limits to help prevent bad requests.\n   *\n   * @returns {EmbedsBuilder}\n   */\n  validate(): this {\n    let totalCharacters = 0\n\n    if (this.length > 10) {\n      throw new Error('You can not have more than 10 embeds on a single message.')\n    }\n\n    this.forEach(({ author, description, fields, footer, title }, index) => {\n      if (title) {\n        const trimmedTitle = title.trim()\n\n        if (trimmedTitle.length > 256) {\n          throw new Error(`Title of embed ${index} can not be longer than 256 characters.`)\n        }\n\n        totalCharacters += trimmedTitle.length\n      }\n\n      if (description) {\n        const trimmedDescription = description.trim()\n\n        if (trimmedDescription.length > 4096) {\n          throw new Error(`Description of embed ${index} can not be longer than 4096 characters.`)\n        }\n\n        totalCharacters += trimmedDescription.length\n      }\n\n      if (fields) {\n        if (fields.length > 25) {\n          throw new Error(`embed ${index} can not have more than 25 fields.`)\n        }\n\n        fields.forEach(({ name, value }, fieldIndex) => {\n          const trimmedName = name.trim()\n          const trimmedValue = value.trim()\n\n          if (trimmedName.length > 256) {\n            throw new Error(`Name of field ${fieldIndex} on embed ${index} can not be longer than 256 characters.`)\n          }\n\n          if (trimmedValue.length > 4096) {\n            throw new Error(`Value of field ${fieldIndex} on embed ${index} can not be longer than 1024 characters.`)\n          }\n\n          totalCharacters += trimmedName.length\n          totalCharacters += trimmedValue.length\n        })\n      }\n\n      if (footer) {\n        const trimmedFooterText = footer.text.trim()\n\n        if (trimmedFooterText.length > 2048) {\n          throw new Error(`Footer text of embed ${index} can not be longer than 2048 characters.`)\n        }\n\n        totalCharacters += trimmedFooterText.length\n      }\n\n      if (author) {\n        const trimmedAuthorName = author.name.trim()\n\n        if (trimmedAuthorName.length > 256) {\n          throw new Error(`Author name of embed ${index} can not be longer than 256 characters.`)\n        }\n\n        totalCharacters += trimmedAuthorName.length\n      }\n    })\n\n    if (totalCharacters > 6000) {\n      throw new Error('Total character length of all embeds can not exceed 6000 characters.')\n    }\n\n    return this\n  }\n\n  /**\n   * Returns the current embed.\n   *\n   * @readonly\n   * @type {DiscordEmbed}\n   */\n  get #currentEmbed(): DiscordEmbed {\n    if (this.length === 0) {\n      this.newEmbed()\n      this.setCurrentEmbed()\n    }\n\n    return this[this.#currentEmbedIndex]\n  }\n}\n"],"names":["EmbedsBuilder","Array","addField","name","value","inline","fields","undefined","push","newEmbed","length","Error","setCurrentEmbed","setAuthor","options","author","setColor","color","convertedValue","parseInt","replace","Number","isNaN","index","setDescription","description","setFields","setFooter","text","footer","setImage","url","image","setProvider","provider","setRandomColor","Math","floor","random","setTitle","title","setUrl","setTimestamp","timestamp","Date","toISOString","setThumbnail","thumbnail","setVideo","video","validate","totalCharacters","forEach","trimmedTitle","trim","trimmedDescription","fieldIndex","trimmedName","trimmedValue","trimmedFooterText","trimmedAuthorName"],"mappings":"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"}

package/dist/cjs/builders.cjs

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createEmbeds", {
+    enumerable: true,
+    get: function() {
+        return createEmbeds;
+    }
+});
+const _embeds = _export_star(require("./builders/embeds.cjs"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}
+const createEmbeds = ()=>new _embeds.EmbedsBuilder();
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9idWlsZGVycy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBFbWJlZHNCdWlsZGVyIH0gZnJvbSAnLi9idWlsZGVycy9lbWJlZHMuanMnXG5cbmV4cG9ydCAqIGZyb20gJy4vYnVpbGRlcnMvZW1iZWRzLmpzJ1xuXG5leHBvcnQgY29uc3QgY3JlYXRlRW1iZWRzID0gKCk6IEVtYmVkc0J1aWxkZXIgPT4gbmV3IEVtYmVkc0J1aWxkZXIoKVxuIl0sIm5hbWVzIjpbImNyZWF0ZUVtYmVkcyIsIkVtYmVkc0J1aWxkZXIiXSwibWFwcGluZ3MiOiI7Ozs7K0JBSWFBOzs7ZUFBQUE7OztxQ0FKaUI7Ozs7Ozs7Ozs7Ozs7O0FBSXZCLE1BQU1BLGVBQWUsSUFBcUIsSUFBSUMscUJBQWEifQ==

package/dist/cjs/casing.cjs

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    camelToSnakeCase: function() {
+        return camelToSnakeCase;
+    },
+    camelize: function() {
+        return camelize;
+    },
+    snakeToCamelCase: function() {
+        return snakeToCamelCase;
+    },
+    snakelize: function() {
+        return snakelize;
+    }
+});
+function camelize(object) {
+    if (Array.isArray(object)) {
+        return object.map((element)=>camelize(element));
+    }
+    if (typeof object === 'object' && object !== null) {
+        const obj = {};
+        Object.keys(object).forEach((key)=>{
+            // @ts-expect-error js hack
+            ;
+            obj[snakeToCamelCase(key)] = camelize(object[key]);
+        });
+        return obj;
+    }
+    return object;
+}
+function snakelize(object) {
+    if (Array.isArray(object)) {
+        return object.map((element)=>snakelize(element));
+    }
+    if (typeof object === 'object' && object !== null) {
+        const obj = {};
+        Object.keys(object).forEach((key)=>{
+            // @ts-expect-error js hack
+            ;
+            obj[camelToSnakeCase(key)] = snakelize(object[key]);
+        });
+        return obj;
+    }
+    return object;
+}
+function snakeToCamelCase(str) {
+    if (!str.includes('_')) return str;
+    let result = '';
+    for(let i = 0, len = str.length; i < len; ++i){
+        if (str[i] === '_') {
+            result += str[++i].toUpperCase();
+            continue;
+        }
+        result += str[i];
+    }
+    return result;
+}
+function camelToSnakeCase(str) {
+    let result = '';
+    for(let i = 0, len = str.length; i < len; ++i){
+        if (str[i] >= 'A' && str[i] <= 'Z') {
+            result += `_${str[i].toLowerCase()}`;
+            continue;
+        }
+        result += str[i];
+    }
+    return result;
+}
+
+//# sourceMappingURL=data:application/json;base64,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