'use strict';

const typeGuard = require('./type-guard-8fd7909d.js');
const log = require('./global-slimmer-registry-7bbdb1f2.js');

/**
 * The `StateBorderColorFormatter` class in TypeScript formats border color tokens based on
 * input values and provides an array of CSS states.
 */
class StateBorderColorFormatter extends typeGuard.StateVariantFormatter {
  constructor() {
    super(...arguments);
    this.states = ['default', 'focus-visible', 'hover', 'active'];
  }
  /**
   * The function `formatToken` takes a BorderColorsTokenType input, checks if it is a valid border
   * color token type, and returns the corresponding CSS border-color value or logs a warning if the
   * input is invalid.
   *
   * @param {BorderColorsTokenType} input - BorderColorsTokenType
   * @returns {string} The `formatToken` function returns a string that represents a CSS style for border color
   * based on the input `BorderColorsTokenType`. If the input is a valid border color token type, it
   * retrieves the corresponding value from the `BorderColorMap` and returns a CSS style string with the
   * border color value. If the input is not a valid border color token type, it logs a warning message
   * and returns an
   */
  formatToken(input) {
    if (typeGuard.isBorderColorTokenType(input)) {
      const tokenValue = typeGuard.BorderColorMap[input];
      return `border-color: ${tokenValue};`;
    }
    else {
      log.LogUtility.warn(`The borderColor value ${input} is invalid, it must be a value of: `, typeGuard.BorderColors);
      return '';
    }
  }
  /**
   * The function `getStates` returns an array of `CssStatesType` objects.
   *
   * @returns {CssStatesType[]} An array of CssStatesType objects is being returned.
   */
  getStates() {
    return this.states;
  }
}
const StateBorderColorFormatter$1 = new StateBorderColorFormatter();

/**
 * The `StateShadowFormatter` class in TypeScript formats a CSS `box-shadow` property based on a
 * ShadowsTokenType input and provides an array of CssStatesType objects.
 */
class StateShadowFormatter extends typeGuard.StateVariantFormatter {
  constructor() {
    super(...arguments);
    this.states = ['default', 'focus-visible', 'hover'];
  }
  /**
   * The `formatToken` function in TypeScript takes a ShadowsTokenType input, validates it, and returns a
   * formatted CSS box-shadow property string or logs a warning if the input is invalid.
   *
   * @param {ShadowsTokenType} input - ShadowsTokenType
   * @returns {string} The `formatToken` function takes a `ShadowsTokenType` input and returns a CSS `box-shadow`
   * property with the corresponding value from the `ShadowMap` object. If the input is not a valid
   * `ShadowsTokenType`, it logs a warning message using `LogUtility.warn` and returns an empty string.
   */
  formatToken(input) {
    if (typeGuard.isShadowsTokenType(input)) {
      const tokenValue = typeGuard.ShadowMap[input];
      return `box-shadow: ${tokenValue};`;
    }
    else {
      log.LogUtility.warn(`The shadow value ${input} is invalid, it must be a value of: `, typeGuard.Shadows);
      return '';
    }
  }
  /**
   * The function `getStates` returns an array of `CssStatesType` objects.
   *
   * @returns {CssStatesType[]}An array of CssStatesType objects is being returned.
   */
  getStates() {
    return this.states;
  }
}
const StateShadowFormatter$1 = new StateShadowFormatter();

/**
 * The `StateBorderFormatter` class in TypeScript formats border token values into CSS border properties
 * and provides state information.
 */
class StateBorderFormatter extends typeGuard.StateVariantFormatter {
  constructor() {
    super(...arguments);
    this.states = ['default', 'focus-visible', 'hover', 'active'];
  }
  /**
   * The `formatToken` function in TypeScript formats a border token value into a CSS border property
   * string or logs a warning if the input is invalid.
   *
   * @param {BordersTokenType} input - The `formatToken` function takes a `BordersTokenType` as input
   * and returns a formatted string representing a CSS border property based on the input token value.
   * If the input is a valid border token type, it retrieves the corresponding CSS value from the
   * `BorderMap` and returns it in a `border
   * @returns {string} The `formatToken` function returns a string that represents a CSS border property based on
   * the input `BordersTokenType`. If the input is a valid border token type, it retrieves the
   * corresponding value from the `BorderMap` and returns a CSS `border` property string. If the input
   * is not a valid border token type, it logs a warning message using `LogUtility.warn` and returns an
   * empty
   */
  formatToken(input) {
    if (typeGuard.isBorderTokenType(input)) {
      const tokenValue = typeGuard.BorderMap[input];
      return `border: ${tokenValue};`;
    }
    else {
      log.LogUtility.warn(`The border value ${input} is invalid, it must be a value of: `, typeGuard.Borders);
      return '';
    }
  }
  /**
   * The function `getStates` returns an array of `CssStatesType` objects.
   *
   * @returns {CssStatesType[] } An array of objects of type CssStatesType, which represents the states.
   */
  getStates() {
    return this.states;
  }
}
const StateBorderFormatter$1 = new StateBorderFormatter();

exports.StateBorderColorFormatter = StateBorderColorFormatter$1;
exports.StateBorderFormatter = StateBorderFormatter$1;
exports.StateShadowFormatter = StateShadowFormatter$1;
