@heartlandone/vega 2.74.0-RTE-table-preview → 2.75.0-RTE-table-preview

package/dist/vega/design-token-56b26205.js

@@ -1,402 +0,0 @@
-import { k as StateVariantFormatter, l as isBorderColorTokenType, e as BorderColorMap, b as BorderColors, m as isShadowsTokenType, h as ShadowMap, f as Shadows, n as isBorderTokenType, o as BorderMap, p as Borders, q as StateBackgroundColorFormatter, r as isSpacingTokenType, j as Spacing, s as isBorderStyleType, t as isBorderRadiusTokenType, B as BorderRadius, C as Colors, u as isBackgroundColorTokenType, v as isTextColorTokenType, w as isBreakpointsTokenType, x as isTypographyTokenType } from './type-guard-09acedc9.js';
-import { B as Breakpoints } from './breakpoints-d9faf11c.js';
-import { L as LogUtility } from './vega-slimmer-core-83fd0e22.js';
-import { r as responsiveFormatFacade } from './responsive-format-facade-98596535.js';
-import { a as TypographyKeys } from './typography-396de03f.js';
-import { e as BorderStyle } from './ui-189dae23.js';
-
-/**
- * The `StateBorderColorFormatter` class in TypeScript formats border color tokens based on
- * input values and provides an array of CSS states.
- */
-class StateBorderColorFormatter extends 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 (isBorderColorTokenType(input)) {
-      const tokenValue = BorderColorMap[input];
-      return `border-color: ${tokenValue};`;
-    }
-    else {
-      LogUtility.warn(`The borderColor value ${input} is invalid, it must be a value of: `, 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 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 (isShadowsTokenType(input)) {
-      const tokenValue = ShadowMap[input];
-      return `box-shadow: ${tokenValue};`;
-    }
-    else {
-      LogUtility.warn(`The shadow value ${input} is invalid, it must be a value of: `, 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 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 (isBorderTokenType(input)) {
-      const tokenValue = BorderMap[input];
-      return `border: ${tokenValue};`;
-    }
-    else {
-      LogUtility.warn(`The border value ${input} is invalid, it must be a value of: `, 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();
-
-/**
- * The `StateFormatFacade` class in TypeScript provides a method to format different types of
- * state variants based on a specified flag.
- */
-class StateFormatFacade {
-  /**
-   * The function `format` takes in an input and a flag, then formats the input based on the flag
-   * provided.
-   *
-   * @param {StateVariantType} input - The `input` parameter in the `format` function is of type
-   * `StateVariantType<ManagedStateScopeInput[Flag], State>`. This means that it expects an input value
-   * that corresponds to the specified flag and state. The `Flag` type is a key of
-   * `ManagedStateScopeInput
-   * @param {keyof ManagedStateScopeInput} flag - The `flag` parameter in the `format` function is a key of the
-   * `ManagedStateScopeInput` type. It is used to determine which formatting logic to apply based on the
-   * specific flag provided. The function then switches on the flag value to select the appropriate
-   * formatting logic for that particular flag.
-   * @returns {string} The `format` function takes in an input of type
-   * `StateVariantType<ManagedStateScopeInput[Flag], State>` and a flag of type `Flag`. It then switches
-   * on the flag value and returns a formatted string based on the flag value. The return value depends
-   * on the flag value:
-   */
-  format(input, flag) {
-    switch (flag) {
-      case 'backgroundColor':
-        return StateBackgroundColorFormatter.format(input);
-      case 'borderColor':
-        return StateBorderColorFormatter$1.format(input);
-      case 'shadow':
-        return StateShadowFormatter$1.format(input);
-      case 'border':
-        return StateBorderFormatter$1.format(input);
-      default:
-        throw new Error(`Invalid flag ${flag} passed into StateFormatFacade`);
-    }
-  }
-}
-const StateFormatFacade$1 = new StateFormatFacade();
-
-/**
- * It logs a warning message to the console.
- *
- * @param {string} tokenType - The name of the token type.
- * @param {unknown} value - The value that was passed into the token.
- * @param {unknown} availableOptions - The available options for the token type.
- */
-function logInvalidValueMessage(tokenType, value, availableOptions) {
-  LogUtility.warn(`The ${tokenType} value ${value} is invalid, it must be a value of: `, availableOptions);
-}
-/**
- * Given a token and an array of modes, return a string with the token formatted with the appropriate mode
- *
- * @param {string} token - The name of the token.
- * @param {TokenMode[]} modes - TokenMode[]
- * @returns {string} The formatted token.
- */
-function formatTokenWithModes(token, modes) {
-  let formattedToken = '';
-  if (modes.includes('dark')) {
-    formattedToken += ` dark:v-dark-${token}`;
-  }
-  return formattedToken;
-}
-/**
- * If the token is a valid spacing token, return the CSS class string. Otherwise, log an error message
- *
- * @param {unknown} token - The value that was passed into the function.
- * @returns {Nullable<string>} The the CSS class string of the padding token.
- */
-function formatAndValidPadding(token) {
-  if (isSpacingTokenType(token)) {
-    return `v-p-${token}`;
-  }
-  else {
-    logInvalidValueMessage('padding', token, Object.keys(Spacing));
-  }
-}
-/**
- * The function `formatAndValidBorderStyle` formats a border style token and returns a string if it is
- * a valid border style type, otherwise it logs an invalid value message.
- *
- * @param {unknown} token - The `token` parameter is a value that represents a border style type.
- * @returns {Nullable<string>} The function `formatAndValidBorderStyle` returns a string that is formatted as
- * `v-border-` if the `token` parameter is of a valid border style type. If the `token` is not
- * a valid border style type, it logs an invalid value message and does not return anything (implicitly
- * returns `undefined`).
- */
-function formatAndValidBorderStyle(token) {
-  if (isBorderStyleType(token)) {
-    return `v-border-${token}`;
-  }
-  else {
-    logInvalidValueMessage('border-style', token, BorderStyle);
-  }
-}
-/**
- * If the token is a valid border radius, return a string with the token prefixed with `v-rounded-`. Otherwise, log an
- * error message
- *
- * @param {unknown} token - The value passed in by the user.
- * @returns {Nullable<string>} The the CSS class string of the border radius token.
- */
-function formatAndValidBorderRadius(token) {
-  if (isBorderRadiusTokenType(token)) {
-    return `v-${token}`;
-  }
-  else {
-    logInvalidValueMessage('border-radius', token, Object.keys(BorderRadius));
-  }
-}
-/**
- * If the token is a valid border color, return CSS class string of the border color. Otherwise, log an error message
- *
- * @param {unknown} token - The value passed in by the user.
- * @returns {Nullable<string>}  return the CSS class string of the border color
- */
-function formatAndValidBorderColor(token) {
-  if (isBorderColorTokenType(token)) {
-    return `v-${token}`;
-  }
-  else {
-    logInvalidValueMessage('border-color', token, Colors.filter(() => /^border-color-.+$/.test));
-  }
-}
-/**
- * If the token is a valid border, return CSS class string of the border. Otherwise, log an error message
- *
- * @param {unknown} token - The value passed in by the user.
- * @returns {Nullable<string>}  return the CSS class string of the border
- */
-function formatAndValidBorder(token) {
-  if (isBorderTokenType(token)) {
-    return `v-${token}`;
-  }
-  else {
-    logInvalidValueMessage('border', token, Borders.filter(() => /^border-.+$/.test));
-  }
-}
-/**
- * If the token is a valid background color, return it with the v- prefix. Otherwise, log an error
- *
- * @param {unknown} token - The value of the token.
- * @param {TokenMode[]} withModes - TokenMode[] = []
- * @returns {Nullable<string>} CSS class string for the background color token with modes supported.
- */
-function formatAndValidBackgroundColor(token, withModes = []) {
-  if (isBackgroundColorTokenType(token)) {
-    return `v-${token}` + formatTokenWithModes(token, withModes);
-  }
-  else {
-    logInvalidValueMessage('background-color', token, Colors.filter(() => /^bg-.+$/.test));
-  }
-}
-/**
- * If the token is a valid text color, return the token prefixed with `v-` and formatted with the given modes. Otherwise,
- * log an error
- *
- * @param {unknown} token - The token to format.
- * @param {TokenMode[]} withModes - TokenMode[] = []
- * @returns {Nullable<string>} A CSS class string that is either a valid color or a valid color with modes.
- */
-function formatAndValidTextColor(token, withModes = []) {
-  if (isTextColorTokenType(token)) {
-    return `v-${token}` + formatTokenWithModes(token, withModes);
-  }
-  else {
-    logInvalidValueMessage('text-color', token, Colors.filter(() => /^text-.+$/.test));
-  }
-}
-/**
- * If the token is a valid breakpoint, return CSS class string for the flex breakpoint. Otherwise, log an error
- *
- * @param {unknown} token - The value of the breakpoint.
- * @returns {Nullable<string>} CSS class string for the flex breakpoint.
- */
-function formatAndValidFlexBreakpoint(token) {
-  if (isBreakpointsTokenType(token)) {
-    return `vega-flex-${token}`;
-  }
-  else {
-    logInvalidValueMessage('breakpoint', token, Object.keys(Breakpoints));
-  }
-}
-/**
- * If the token is a breakpoint, return the breakpoint value. Otherwise, log an error and return 0
- *
- * @param {unknown} token - The value passed in by the user.
- * @returns {Nullable<number>} value of the breakpoint.
- */
-function formatAndValidBreakpointSize(token) {
-  if (isBreakpointsTokenType(token)) {
-    return Breakpoints[token];
-  }
-  else {
-    logInvalidValueMessage('breakpoint', token, Object.keys(Breakpoints));
-  }
-}
-/**
- * If the token is a valid spacing token, return a string with the token name prefixed with `v-gap-`. Otherwise, log an
- * error message
- *
- * @param {unknown} token - The value passed in by the user.
- * @returns {Nullable<string>} CSS class string for the given gap token.
- */
-function formatAndValidGap(token) {
-  if (isSpacingTokenType(token)) {
-    return `v-gap-${token}`;
-  }
-  else {
-    logInvalidValueMessage('gap', token, Object.keys(Spacing));
-  }
-}
-/**
- * If the token is a valid shadows token type, return the token with the prefix "v-". Otherwise, log an error message
- *
- * @param {string} token - The token to format.
- * @param {TokenMode[]} withModes - TokenMode[] = []
- * @returns {Nullable<string>} CSS class string of the shadow token with modes supported
- */
-function formatAndValidShadow(token, withModes = []) {
-  if (isShadowsTokenType(token)) {
-    return `v-${token}` + formatTokenWithModes(token, withModes);
-  }
-  else {
-    logInvalidValueMessage('shadows', token, Shadows);
-  }
-}
-/**
- * It takes a token and a flag, and returns a string
- *
- * @typedef Flag key of ManagedResponsiveScopeInput
- * @param {ResponsiveType<ManagedResponsiveScopeInput[Flag]>} token - The token to format.
- * @param {Flag} flag - The flag that the token is being formatted for.
- * @returns {Nullable<ManagedResponsiveScopeOutput[Flag]>} A nullable string
- */
-function formatAndValidResponsiveToken(token, flag) {
-  if (token !== null && token !== undefined) {
-    return responsiveFormatFacade.format(token, flag);
-  }
-}
-/**
- * The function `formatAndValidTypographyToken` formats a typography token by adding a prefix and checks if it is a valid typography token.
- *
- * @param {string} token - The `token` parameter is a string that represents a typography token.
- * @returns {Nullable<string>} a string value.
- */
-function formatAndValidTypographyToken(token) {
-  if (isTypographyTokenType(token)) {
-    return `v-${token}`;
-  }
-  else {
-    logInvalidValueMessage('font', token, TypographyKeys);
-  }
-}
-/**
- * The function `formatAndValidStateToken` formats and validates a state token based on a specified flag.
- *
- * @param {StateVariantType} token - The `token` parameter is a value that represents a state variant for a specific flag
- * in a managed state scope input.
- * @param {Flag} flag - The `flag` parameter is a key of the `ManagedStateScopeInput` type.
- * @returns {Nullable<string>} a formatted and validated state token as a string, or `null` if the input token is `null`
- * or `undefined`.
- */
-function formatAndValidStateToken(token, flag) {
-  if (token !== null && token !== undefined) {
-    return StateFormatFacade$1.format(token, flag);
-  }
-}
-
-export { formatAndValidGap as a, formatAndValidShadow as b, formatAndValidBreakpointSize as c, formatAndValidBackgroundColor as d, formatAndValidBorderColor as e, formatAndValidResponsiveToken as f, formatAndValidBorderRadius as g, formatAndValidPadding as h, formatAndValidTextColor as i, formatAndValidTypographyToken as j, formatAndValidStateToken as k, formatAndValidBorderStyle as l, formatAndValidFlexBreakpoint as m };