@svintsow/discord-components 1.0.0

package/dist/index.mjs

@@ -0,0 +1,868 @@
+// src/enums/ComponentType.ts
+var ComponentType = /* @__PURE__ */ ((ComponentType2) => {
+  ComponentType2[ComponentType2["Container"] = 1] = "Container";
+  ComponentType2[ComponentType2["Section"] = 2] = "Section";
+  ComponentType2[ComponentType2["TextDisplay"] = 3] = "TextDisplay";
+  ComponentType2[ComponentType2["Thumbnail"] = 4] = "Thumbnail";
+  ComponentType2[ComponentType2["MediaGallery"] = 5] = "MediaGallery";
+  ComponentType2[ComponentType2["MediaGalleryItem"] = 6] = "MediaGalleryItem";
+  ComponentType2[ComponentType2["Separator"] = 7] = "Separator";
+  ComponentType2[ComponentType2["File"] = 8] = "File";
+  ComponentType2[ComponentType2["Label"] = 9] = "Label";
+  return ComponentType2;
+})(ComponentType || {});
+
+// src/constants/limits.ts
+var Limits = {
+  MAX_COMPONENTS_PER_CONTAINER: 5,
+  MAX_TEXT_LENGTH: 2e3,
+  MAX_DESCRIPTION_LENGTH: 2e3,
+  MAX_LABEL_LENGTH: 80,
+  MAX_FILENAME_LENGTH: 255,
+  MAX_GALLERY_ITEMS: 10,
+  MAX_URL_LENGTH: 2048
+};
+
+// src/errors/ValidationError.ts
+var ValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ValidationError";
+  }
+};
+
+// src/errors/InvalidComponentError.ts
+var InvalidComponentError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InvalidComponentError";
+  }
+};
+
+// src/errors/InvalidURLException.ts
+var InvalidURLException = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InvalidURLException";
+  }
+};
+
+// src/errors/ComponentLimitError.ts
+var ComponentLimitError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ComponentLimitError";
+  }
+};
+
+// src/builders/base/ComponentBuilder.ts
+var ComponentBuilder = class {
+  clone() {
+    const data = this.toJSON();
+    const Constructor = this.constructor;
+    const instance = new Constructor();
+    return instance.fromJSON(data);
+  }
+  static from(data) {
+    const instance = new this();
+    return instance.fromJSON(data);
+  }
+  fromJSON(data) {
+    return this;
+  }
+};
+
+// src/builders/base/AccessoryBuilder.ts
+var AccessoryBuilder = class extends ComponentBuilder {
+  setStyle(style) {
+    this.style = style;
+    return this;
+  }
+  toJSON() {
+    const data = {
+      type: this.type
+    };
+    if (this.style) {
+      data.style = this.style;
+    }
+    return data;
+  }
+};
+
+// src/validation/validators/URLValidator.ts
+var URLValidator = class {
+  static validate(url) {
+    try {
+      new URL(url);
+    } catch {
+      throw new InvalidURLException(`Invalid URL: ${url}`);
+    }
+  }
+  static validateOptional(url) {
+    if (url) {
+      this.validate(url);
+    }
+  }
+};
+
+// src/utils/urlUtils.ts
+var UrlUtils = class {
+  static isValidUrl(url) {
+    try {
+      new URL(url);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  static normalizeUrl(url) {
+    if (!this.isValidUrl(url)) {
+      throw new Error("Invalid URL");
+    }
+    return url.trim();
+  }
+};
+
+// src/utils/stringUtils.ts
+var StringUtils = class {
+  static isString(value) {
+    return typeof value === "string";
+  }
+  static truncate(text, maxLength) {
+    if (text.length <= maxLength)
+      return text;
+    return text.slice(0, maxLength - 3) + "...";
+  }
+  static validateLength(text, maxLength, field) {
+    if (text && text.length > maxLength) {
+      throw new Error(`${field} exceeds maximum length of ${maxLength}`);
+    }
+  }
+};
+
+// src/utils/arrayUtils.ts
+var ArrayUtils = class {
+  static isValidArray(arr) {
+    return Array.isArray(arr);
+  }
+  static ensureArray(items) {
+    return Array.isArray(items) ? items : [items];
+  }
+  static splice(arr, index, deleteCount, ...items) {
+    const result = [...arr];
+    result.splice(index, deleteCount, ...items);
+    return result;
+  }
+};
+
+// src/utils/objectUtils.ts
+var ObjectUtils = class {
+  static deepClone(obj) {
+    return JSON.parse(JSON.stringify(obj));
+  }
+  static hasOwnProperty(obj, prop) {
+    return Object.prototype.hasOwnProperty.call(obj, prop);
+  }
+  static mergeDeep(target, source) {
+    const result = { ...target };
+    for (const key in source) {
+      if (this.hasOwnProperty(source, key)) {
+        result[key] = source[key];
+      }
+    }
+    return result;
+  }
+};
+
+// src/validation/validators/StringValidator.ts
+var StringValidator = class {
+  static validate(value, field) {
+    if (!StringUtils.isString(value)) {
+      throw new ValidationError(`${field} must be a string`);
+    }
+  }
+  static validateLength(value, maxLength, field) {
+    if (value && value.length > maxLength) {
+      throw new ValidationError(
+        `${field} must be at most ${maxLength} characters, got ${value.length}`
+      );
+    }
+  }
+  static validateOptional(value, field) {
+    if (value !== void 0 && value !== null) {
+      this.validate(value, field || "Value");
+    }
+  }
+};
+
+// src/validation/validators/ComponentValidator.ts
+var ComponentValidator = class {
+  static validateType(type) {
+    if (!Object.values(ComponentType).includes(type)) {
+      throw new ValidationError(`Invalid component type: ${type}`);
+    }
+  }
+  static validateComponentStructure(obj) {
+    if (!obj || typeof obj !== "object") {
+      throw new ValidationError("Component must be an object");
+    }
+    if (!obj.type) {
+      throw new ValidationError("Component must have a type");
+    }
+    this.validateType(obj.type);
+  }
+};
+
+// src/validation/rules/limitRules.ts
+var LimitRules = class {
+  static validateComponentCount(count) {
+    if (count > Limits.MAX_COMPONENTS_PER_CONTAINER) {
+      throw new ComponentLimitError(
+        `Maximum ${Limits.MAX_COMPONENTS_PER_CONTAINER} components allowed, got ${count}`
+      );
+    }
+  }
+  static validateGalleryItems(count) {
+    if (count > Limits.MAX_GALLERY_ITEMS) {
+      throw new ComponentLimitError(
+        `Maximum ${Limits.MAX_GALLERY_ITEMS} gallery items allowed, got ${count}`
+      );
+    }
+  }
+};
+
+// src/validation/rules/nestingRules.ts
+var NestingRules = class {
+  static validateContainerNesting(componentType) {
+    const allowedTypes = [
+      1 /* Container */,
+      2 /* Section */,
+      3 /* TextDisplay */,
+      4 /* Thumbnail */,
+      5 /* MediaGallery */,
+      7 /* Separator */,
+      8 /* File */,
+      9 /* Label */
+    ];
+    if (!allowedTypes.includes(componentType)) {
+      throw new InvalidComponentError(
+        `Component type ${componentType} cannot be nested in Container`
+      );
+    }
+  }
+  static validateSectionNesting(componentType) {
+    const allowedTypes = [
+      3 /* TextDisplay */,
+      4 /* Thumbnail */,
+      5 /* MediaGallery */,
+      8 /* File */,
+      9 /* Label */,
+      7 /* Separator */
+    ];
+    if (!allowedTypes.includes(componentType)) {
+      throw new InvalidComponentError(
+        `Component type ${componentType} cannot be nested in Section`
+      );
+    }
+  }
+};
+
+// src/components/parser/ComponentParser.ts
+var ComponentParser = class {
+  static parse(data) {
+    if (!data || typeof data !== "object") {
+      throw new ValidationError("Invalid component data");
+    }
+    if (!data.type) {
+      throw new ValidationError("Component data must have type");
+    }
+    switch (data.type) {
+      case 1 /* Container */:
+        return ContainerBuilder.from(data);
+      case 2 /* Section */:
+        return SectionBuilder.from(data);
+      case 3 /* TextDisplay */:
+        return TextDisplayBuilder.from(data);
+      case 4 /* Thumbnail */:
+        return ThumbnailBuilder.from(data);
+      case 5 /* MediaGallery */:
+        return MediaGalleryBuilder.from(data);
+      case 6 /* MediaGalleryItem */:
+        return MediaGalleryItemBuilder.from(data);
+      case 7 /* Separator */:
+        return SeparatorBuilder.from(data);
+      case 8 /* File */:
+        return FileBuilder.from(data);
+      case 9 /* Label */:
+        return LabelBuilder.from(data);
+      default:
+        throw new ValidationError(`Unknown component type: ${data.type}`);
+    }
+  }
+  static parseMany(dataArray) {
+    return dataArray.map((data) => this.parse(data));
+  }
+};
+
+// src/builders/container/ContainerBuilder.ts
+var ContainerBuilder = class _ContainerBuilder extends ComponentBuilder {
+  constructor() {
+    super();
+    this.components = [];
+    this.type = 1 /* Container */;
+  }
+  addComponents(...components) {
+    for (const component of components) {
+      const componentType = component.type || component.constructor.type;
+      if (componentType !== 1 /* Container */) {
+        NestingRules.validateContainerNesting(componentType);
+      }
+    }
+    const newCount = this.components.length + components.length;
+    LimitRules.validateComponentCount(newCount);
+    this.components.push(...components);
+    return this;
+  }
+  spliceComponents(index, deleteCount, ...components) {
+    if (index < 0 || index > this.components.length) {
+      throw new ValidationError(`Invalid index: ${index}`);
+    }
+    for (const component of components) {
+      const componentType = component.type || component.constructor.type;
+      if (componentType !== 1 /* Container */) {
+        NestingRules.validateContainerNesting(componentType);
+      }
+    }
+    const newCount = this.components.length - deleteCount + components.length;
+    LimitRules.validateComponentCount(newCount);
+    this.components = ArrayUtils.splice(
+      this.components,
+      index,
+      deleteCount,
+      ...components
+    );
+    return this;
+  }
+  clearComponents() {
+    this.components = [];
+    return this;
+  }
+  toJSON() {
+    return {
+      type: this.type,
+      components: this.components.map((comp) => comp.toJSON())
+    };
+  }
+  fromJSON(data) {
+    if (!data.components || !Array.isArray(data.components)) {
+      throw new ValidationError("Container data must have components array");
+    }
+    this.components = data.components.map((compData) => {
+      return ComponentParser.parse(compData);
+    });
+    return this;
+  }
+  clone() {
+    const cloned = new _ContainerBuilder();
+    cloned.components = this.components.map((comp) => comp.clone());
+    return cloned;
+  }
+};
+
+// src/builders/section/SectionBuilder.ts
+var SectionBuilder = class _SectionBuilder extends ComponentBuilder {
+  constructor() {
+    super();
+    this.texts = [];
+    this.accessory = null;
+    this.type = 2 /* Section */;
+  }
+  addText(...textComponents) {
+    for (const component of textComponents) {
+      NestingRules.validateSectionNesting(component.type);
+    }
+    this.texts.push(...textComponents);
+    return this;
+  }
+  setAccessory(accessory) {
+    this.accessory = accessory;
+    return this;
+  }
+  clearAccessory() {
+    this.accessory = null;
+    return this;
+  }
+  toJSON() {
+    const data = {
+      type: this.type,
+      texts: this.texts.map((text) => text.toJSON())
+    };
+    if (this.accessory) {
+      data.accessory = this.accessory.toJSON();
+    }
+    return data;
+  }
+  fromJSON(data) {
+    if (!data.texts || !Array.isArray(data.texts)) {
+      throw new ValidationError("Section data must have texts array");
+    }
+    this.texts = data.texts.map((textData) => {
+      return ComponentParser.parse(textData);
+    });
+    if (data.accessory) {
+      const parsed = ComponentParser.parse(data.accessory);
+      this.accessory = parsed;
+    }
+    return this;
+  }
+  clone() {
+    const cloned = new _SectionBuilder();
+    cloned.texts = this.texts.map((text) => text.clone());
+    if (this.accessory) {
+      cloned.accessory = this.accessory.clone();
+    }
+    return cloned;
+  }
+};
+
+// src/builders/textDisplay/TextDisplayBuilder.ts
+var TextDisplayBuilder = class _TextDisplayBuilder extends ComponentBuilder {
+  constructor() {
+    super();
+    this.content = "";
+    this.type = 3 /* TextDisplay */;
+  }
+  setContent(text) {
+    StringValidator.validate(text, "Content");
+    StringValidator.validateLength(text, Limits.MAX_TEXT_LENGTH, "Content");
+    this.content = text;
+    return this;
+  }
+  toJSON() {
+    if (!this.content) {
+      throw new ValidationError("TextDisplay must have content");
+    }
+    return {
+      type: this.type,
+      content: this.content
+    };
+  }
+  fromJSON(data) {
+    if (!data.content) {
+      throw new ValidationError("TextDisplay data must have content");
+    }
+    return this.setContent(data.content);
+  }
+  clone() {
+    const cloned = new _TextDisplayBuilder();
+    cloned.content = this.content;
+    return cloned;
+  }
+};
+
+// src/builders/thumbnail/ThumbnailBuilder.ts
+var ThumbnailBuilder = class _ThumbnailBuilder extends ComponentBuilder {
+  constructor() {
+    super();
+    // Не extends AccessoryBuilder
+    this.url = "";
+    this.description = "";
+    this.spoiler = false;
+    this.type = 4 /* Thumbnail */;
+  }
+  setURL(url) {
+    URLValidator.validate(url);
+    this.url = url;
+    return this;
+  }
+  setDescription(text) {
+    StringValidator.validate(text, "Description");
+    StringValidator.validateLength(
+      text,
+      Limits.MAX_DESCRIPTION_LENGTH,
+      "Description"
+    );
+    this.description = text;
+    return this;
+  }
+  setSpoiler(spoiler) {
+    this.spoiler = spoiler;
+    return this;
+  }
+  toJSON() {
+    if (!this.url) {
+      throw new ValidationError("Thumbnail must have URL");
+    }
+    const data = {
+      type: this.type,
+      url: this.url
+    };
+    if (this.description) {
+      data.description = this.description;
+    }
+    if (this.spoiler) {
+      data.spoiler = this.spoiler;
+    }
+    return data;
+  }
+  fromJSON(data) {
+    if (!data.url) {
+      throw new ValidationError("Thumbnail data must have URL");
+    }
+    this.setURL(data.url);
+    if (data.description) {
+      this.setDescription(data.description);
+    }
+    if (data.spoiler !== void 0) {
+      this.setSpoiler(data.spoiler);
+    }
+    return this;
+  }
+  clone() {
+    const cloned = new _ThumbnailBuilder();
+    cloned.url = this.url;
+    cloned.description = this.description;
+    cloned.spoiler = this.spoiler;
+    return cloned;
+  }
+};
+
+// src/builders/mediaGallery/MediaGalleryItemBuilder.ts
+var MediaGalleryItemBuilder = class _MediaGalleryItemBuilder extends ComponentBuilder {
+  constructor() {
+    super();
+    this.url = "";
+    this.description = "";
+    this.spoiler = false;
+    this.type = 6 /* MediaGalleryItem */;
+  }
+  setURL(url) {
+    URLValidator.validate(url);
+    this.url = url;
+    return this;
+  }
+  setDescription(text) {
+    StringValidator.validate(text, "Description");
+    StringValidator.validateLength(
+      text,
+      Limits.MAX_DESCRIPTION_LENGTH,
+      "Description"
+    );
+    this.description = text;
+    return this;
+  }
+  setSpoiler(spoiler) {
+    this.spoiler = spoiler;
+    return this;
+  }
+  toJSON() {
+    if (!this.url) {
+      throw new ValidationError("MediaGalleryItem must have URL");
+    }
+    const data = {
+      type: this.type,
+      url: this.url
+    };
+    if (this.description) {
+      data.description = this.description;
+    }
+    if (this.spoiler) {
+      data.spoiler = this.spoiler;
+    }
+    return data;
+  }
+  fromJSON(data) {
+    if (!data.url) {
+      throw new ValidationError("MediaGalleryItem data must have URL");
+    }
+    this.setURL(data.url);
+    if (data.description) {
+      this.setDescription(data.description);
+    }
+    if (data.spoiler !== void 0) {
+      this.setSpoiler(data.spoiler);
+    }
+    return this;
+  }
+  clone() {
+    const cloned = new _MediaGalleryItemBuilder();
+    cloned.url = this.url;
+    cloned.description = this.description;
+    cloned.spoiler = this.spoiler;
+    return cloned;
+  }
+};
+
+// src/builders/mediaGallery/MediaGalleryBuilder.ts
+var MediaGalleryBuilder = class _MediaGalleryBuilder extends ComponentBuilder {
+  constructor() {
+    super();
+    this.items = [];
+    this.type = 5 /* MediaGallery */;
+  }
+  addItems(...items) {
+    const newCount = this.items.length + items.length;
+    LimitRules.validateGalleryItems(newCount);
+    this.items.push(...items);
+    return this;
+  }
+  spliceItems(index, deleteCount, ...items) {
+    if (index < 0 || index > this.items.length) {
+      throw new ValidationError(`Invalid index: ${index}`);
+    }
+    const newCount = this.items.length - deleteCount + items.length;
+    LimitRules.validateGalleryItems(newCount);
+    this.items = ArrayUtils.splice(this.items, index, deleteCount, ...items);
+    return this;
+  }
+  clearItems() {
+    this.items = [];
+    return this;
+  }
+  toJSON() {
+    return {
+      type: this.type,
+      items: this.items.map((item) => item.toJSON())
+    };
+  }
+  fromJSON(data) {
+    if (!data.items || !Array.isArray(data.items)) {
+      throw new ValidationError("MediaGallery data must have items array");
+    }
+    this.items = data.items.map((itemData) => {
+      return MediaGalleryItemBuilder.from(itemData);
+    });
+    return this;
+  }
+  clone() {
+    const cloned = new _MediaGalleryBuilder();
+    cloned.items = this.items.map((item) => item.clone());
+    return cloned;
+  }
+};
+
+// src/builders/separator/SeparatorBuilder.ts
+var SeparatorBuilder = class _SeparatorBuilder extends ComponentBuilder {
+  constructor() {
+    super();
+    this.spacing = 8;
+    this.divider = true;
+    this.type = 7 /* Separator */;
+  }
+  setSpacing(spacing) {
+    if (spacing < 0 || spacing > 32) {
+      throw new ValidationError("Spacing must be between 0 and 32");
+    }
+    this.spacing = spacing;
+    return this;
+  }
+  setDivider(divider) {
+    this.divider = divider;
+    return this;
+  }
+  toJSON() {
+    const data = {
+      type: this.type,
+      spacing: this.spacing
+    };
+    if (!this.divider) {
+      data.divider = this.divider;
+    }
+    return data;
+  }
+  fromJSON(data) {
+    if (data.spacing !== void 0) {
+      this.setSpacing(data.spacing);
+    }
+    if (data.divider !== void 0) {
+      this.setDivider(data.divider);
+    }
+    return this;
+  }
+  clone() {
+    const cloned = new _SeparatorBuilder();
+    cloned.spacing = this.spacing;
+    cloned.divider = this.divider;
+    return cloned;
+  }
+};
+
+// src/builders/file/FileBuilder.ts
+var FileBuilder = class _FileBuilder extends ComponentBuilder {
+  constructor() {
+    super();
+    this.url = "";
+    this.filename = "";
+    this.description = "";
+    this.type = 8 /* File */;
+  }
+  setURL(url) {
+    URLValidator.validate(url);
+    this.url = url;
+    return this;
+  }
+  setFilename(name) {
+    StringValidator.validate(name, "Filename");
+    StringValidator.validateLength(name, Limits.MAX_FILENAME_LENGTH, "Filename");
+    this.filename = name;
+    return this;
+  }
+  setDescription(text) {
+    StringValidator.validate(text, "Description");
+    StringValidator.validateLength(
+      text,
+      Limits.MAX_DESCRIPTION_LENGTH,
+      "Description"
+    );
+    this.description = text;
+    return this;
+  }
+  toJSON() {
+    if (!this.url) {
+      throw new ValidationError("File must have URL");
+    }
+    if (!this.filename) {
+      throw new ValidationError("File must have filename");
+    }
+    const data = {
+      type: this.type,
+      url: this.url,
+      filename: this.filename
+    };
+    if (this.description) {
+      data.description = this.description;
+    }
+    return data;
+  }
+  fromJSON(data) {
+    if (!data.url || !data.filename) {
+      throw new ValidationError("File data must have URL and filename");
+    }
+    this.setURL(data.url);
+    this.setFilename(data.filename);
+    if (data.description) {
+      this.setDescription(data.description);
+    }
+    return this;
+  }
+  clone() {
+    const cloned = new _FileBuilder();
+    cloned.url = this.url;
+    cloned.filename = this.filename;
+    cloned.description = this.description;
+    return cloned;
+  }
+};
+
+// src/builders/label/LabelBuilder.ts
+var LabelBuilder = class _LabelBuilder extends ComponentBuilder {
+  constructor() {
+    super();
+    this.label = "";
+    this.description = "";
+    this.type = 9 /* Label */;
+  }
+  setLabel(text) {
+    StringValidator.validate(text, "Label");
+    StringValidator.validateLength(text, Limits.MAX_LABEL_LENGTH, "Label");
+    this.label = text;
+    return this;
+  }
+  setDescription(text) {
+    StringValidator.validate(text, "Description");
+    StringValidator.validateLength(
+      text,
+      Limits.MAX_DESCRIPTION_LENGTH,
+      "Description"
+    );
+    this.description = text;
+    return this;
+  }
+  toJSON() {
+    if (!this.label) {
+      throw new ValidationError("Label must have label text");
+    }
+    const data = {
+      type: this.type,
+      label: this.label
+    };
+    if (this.description) {
+      data.description = this.description;
+    }
+    return data;
+  }
+  fromJSON(data) {
+    if (!data.label) {
+      throw new ValidationError("Label data must have label");
+    }
+    this.setLabel(data.label);
+    if (data.description) {
+      this.setDescription(data.description);
+    }
+    return this;
+  }
+  clone() {
+    const cloned = new _LabelBuilder();
+    cloned.label = this.label;
+    cloned.description = this.description;
+    return cloned;
+  }
+};
+
+// src/helpers/componentHelper.ts
+var ComponentHelper = class {
+  static createTextSection(text) {
+    return new SectionBuilder().addText(
+      new TextDisplayBuilder().setContent(text)
+    );
+  }
+  static createContainerFrom(...components) {
+    return new ContainerBuilder().addComponents(...components);
+  }
+};
+
+// src/internal/registry.ts
+var ComponentRegistry = class {
+  static register(name, builder) {
+    this.builders.set(name, builder);
+  }
+  static get(name) {
+    return this.builders.get(name);
+  }
+  static has(name) {
+    return this.builders.has(name);
+  }
+};
+ComponentRegistry.builders = /* @__PURE__ */ new Map();
+export {
+  AccessoryBuilder,
+  ArrayUtils,
+  ComponentBuilder,
+  ComponentHelper,
+  ComponentLimitError,
+  ComponentParser,
+  ComponentRegistry,
+  ComponentType,
+  ComponentValidator,
+  ContainerBuilder,
+  FileBuilder,
+  InvalidComponentError,
+  InvalidURLException,
+  LabelBuilder,
+  LimitRules,
+  Limits,
+  MediaGalleryBuilder,
+  MediaGalleryItemBuilder,
+  NestingRules,
+  ObjectUtils,
+  SectionBuilder,
+  SeparatorBuilder,
+  StringUtils,
+  StringValidator,
+  TextDisplayBuilder,
+  ThumbnailBuilder,
+  URLValidator,
+  UrlUtils,
+  ValidationError
+};
+//# sourceMappingURL=index.mjs.map