@viasat/beam-tokens 2.0.0

package/types/configs/colors/colors.format.d.ts

@@ -0,0 +1,11 @@
+import { Named, Format } from 'style-dictionary';
+import { CssVarsFormatters } from '../../utils';
+/**
+ * Formatter to generate CSS variables for color tokens.
+ */
+export declare const colorCssVarsFormatter: Named<Format>;
+/**
+ * All formatters for color tokens.
+ */
+export declare const colorFormatters: CssVarsFormatters;
+export default colorFormatters;

package/types/configs/colors/colors.transformers.d.ts

@@ -0,0 +1,9 @@
+import { Named, Transform, TransformGroup } from 'style-dictionary';
+import { TokenTransformers } from '../../utils';
+/**
+ * Adds CSS names to color and opacity tokens.
+ */
+export declare const colorTokenCssName: Named<Transform>;
+export declare const colorsTransformGroup: Named<TransformGroup>;
+export declare const colorTransformers: TokenTransformers;
+export default colorTransformers;

package/types/configs/colors/colors.utils.d.ts

@@ -0,0 +1,21 @@
+import { TransformedToken } from 'style-dictionary';
+/**
+ * Checks if the given token is a color token.
+ */
+export declare const isColorToken: (token: TransformedToken) => boolean;
+/**
+ * Checks if the given token represents a gradient.
+ */
+export declare const isGradient: (token: TransformedToken) => boolean;
+/**
+ * Converts hex color to RGBA format.
+ */
+export declare const hexToRgba: (value: string, wrap?: boolean) => string;
+/**
+ * Transforms tokens to RGBA format.
+ */
+export declare const transformToRGBA: (token: TransformedToken) => string;
+/**
+ * Parses gradient token values.
+ */
+export declare const parseGradientTokenValue: (token: TransformedToken) => string;

package/types/configs/colors/index.d.ts

@@ -0,0 +1,5 @@
+import { BuildConfig, ThemeConfig } from '../../utils';
+export * from './sd.colors.config';
+export * from './colors.transformers';
+export declare const colorBuildConfig: BuildConfig;
+export declare const colorThemeConfig: (theme: ThemeConfig) => BuildConfig;

package/types/configs/colors/sd.colors.config.d.ts

@@ -0,0 +1,7 @@
+import { Config, TransformedToken } from 'style-dictionary';
+import { OutPutFilesPaths, CommonConfig } from '../../utils';
+export declare const COMMON_CONFIG: CommonConfig;
+export declare const tokenFilter: (token: TransformedToken) => boolean;
+declare const ViasatConfig: Config[];
+export declare const colorOutputPaths: OutPutFilesPaths;
+export default ViasatConfig;

package/types/configs/components/components.format.css.d.ts

@@ -0,0 +1,16 @@
+import { Named, Format } from 'style-dictionary';
+import { CssVarsFormatters } from '../../utils';
+/**
+ * Generates component prefix
+ */
+export declare const generateComponentPrefix: (componentName: string) => string;
+/**
+ * Formatter to generate CSS variables for a specific component's tokens.
+ * This is called separately for light and dark themes to create theme-specific CSS output.
+ */
+export declare const componentCssVarsFormatter: Named<Format>;
+/**
+ * All formatters for component tokens.
+ */
+export declare const componentFormatters: CssVarsFormatters;
+export default componentFormatters;

package/types/configs/components/components.transformers.d.ts

@@ -0,0 +1,4 @@
+import { Named, TransformGroup } from 'style-dictionary';
+import { TokenTransformers } from '../../utils';
+export declare const componentsTransformGroup: Named<TransformGroup>;
+export declare const componentTransformers: TokenTransformers;

package/types/configs/components/index.d.ts

@@ -0,0 +1,2 @@
+import { BuildConfig } from '../../utils';
+export declare const componentsBuildConfig: BuildConfig;

package/types/configs/components/sd.components.config.d.ts

@@ -0,0 +1,11 @@
+import { Config, TransformedToken } from 'style-dictionary';
+import { OutPutFilesPaths, CommonConfig } from '../../utils';
+export declare const COMMON_CONFIG: CommonConfig;
+/**
+ * Filters tokens to only include component tokens (bm.comp.*)
+ * This excludes utility-comp tokens (bm.utility.comp.*) which should stay in tokens.css
+ */
+export declare const tokenFilter: (token: TransformedToken) => boolean;
+declare const ComponentsConfig: Config[];
+export declare const componentOutputPaths: OutPutFilesPaths;
+export default ComponentsConfig;

package/types/configs/dimensions/dimension.format.css.d.ts

@@ -0,0 +1,8 @@
+import { Named, Format } from 'style-dictionary';
+import { CssVarsFormatters } from '../../utils';
+/**
+ * Formatter to generate CSS variables for dimension tokens.
+ */
+export declare const dimensionCssVarsFormatter: Named<Format>;
+declare const dimensionCssVarsFormatters: CssVarsFormatters;
+export default dimensionCssVarsFormatters;

package/types/configs/dimensions/dimensions.transformers.d.ts

@@ -0,0 +1,9 @@
+import { Named, Transform, TransformGroup } from 'style-dictionary';
+import { TokenTransformers } from '../../utils';
+/** Transforms */
+export declare const parseRawRemTokenValue: Named<Transform>;
+export declare const parseSemTokenValue: Named<Transform>;
+export declare const parseCompTokenValue: Named<Transform>;
+export declare const dimensionTransformGroup: Named<TransformGroup>;
+export declare const dimensionTransformers: TokenTransformers;
+export default dimensionTransformers;

package/types/configs/dimensions/dimensions.utils.d.ts

@@ -0,0 +1,55 @@
+import { TOKEN_CATEGORY, OccurrenceCounts } from '../../utils';
+import { TransformedToken } from 'style-dictionary';
+/**
+ * Checks if the token is a dimension token.
+ */
+export declare const isDimensionToken: (token: TransformedToken, category?: TOKEN_CATEGORY) => boolean;
+/**
+ * Checks if the token is a dimension utility.
+ */
+export declare const isDimensionUtility: (token: TransformedToken) => boolean;
+/**
+ * Converts a mathematical equation to CSS variable format.
+ */
+export declare const convertMathEquationToCssVarFormat: (token: TransformedToken) => string;
+/**
+ * Checks if the value contains a mathematical symbol.
+ */
+export declare const containsMathSymbol: (value: string) => boolean;
+/**
+ * Checks if the value contains a token reference.
+ */
+export declare const containsTokenReference: (value: string) => boolean;
+/**
+ * Determines the token base based on its reference.
+ */
+export declare const getTokenBase: (value: string) => string;
+/**
+ * Converts a token reference to CSS variable format.
+ */
+export declare const convertTokenReferenceToCssVar: (value: string) => string;
+/**
+ * Checks if the occurrences represent a single occurrence.
+ */
+export declare const isSingleOccurrence: (occurrences: OccurrenceCounts) => boolean;
+/**
+ * Checks if the occurrences represent multiple occurrences.
+ */
+export declare const isMultipleOccurrence: (occurrences: OccurrenceCounts) => boolean;
+/**
+ * Converts a single token to CSS variable format.
+ */
+export declare const convertSingleTokenToCssVar: (tokenValue: string, fallback: string) => string;
+/**
+ * Converts multiple tokens to CSS variable format.
+ */
+export declare const convertMultipleTokensToCssVar: (token: TransformedToken) => string;
+/**
+ * Converts a joint token name into an array of formatted CSS variable names.
+ *
+ * @param token - The token containing the joint value.
+ * @param delimiter - The delimiter used to split the token name (default: '.').
+ * @param useCssVarWrapper - Whether to wrap the formatted names in `var(--tokenName)`.
+ * @returns An array of formatted CSS variable names.
+ */
+export declare const convertJointTokenNameToCssVarFormat: (token: TransformedToken, delimiter?: string, useCssVarWrapper?: boolean) => string[];

package/types/configs/dimensions/index.d.ts

@@ -0,0 +1,7 @@
+import { BuildConfig, CssVarsFormatters, ThemeConfig } from '../../utils';
+export * from './sd.dimension.config';
+export * from './dimensions.transformers';
+export declare const dimensionFormatters: CssVarsFormatters;
+export default dimensionFormatters;
+export declare const dimensionBuildConfig: BuildConfig;
+export declare const dimensionThemeConfig: (theme: ThemeConfig) => BuildConfig;

package/types/configs/dimensions/sd.dimension.config.d.ts

@@ -0,0 +1,15 @@
+import { Config, TransformedToken } from 'style-dictionary';
+import { OutPutFilesPaths, CommonConfig } from '../../utils';
+export declare const COMMON_CONFIG: CommonConfig;
+/**
+ * Token filter to identify valid dimension tokens.
+ * Excludes font-size and utility tokens at the product type level.
+ */
+export declare const tokenFilter: (token: TransformedToken) => boolean;
+/** Dimension Style Dictionary Configuration */
+export declare const dimensionStyleDictConfig: Config;
+/** Generate all configurations including theme-specific configs */
+declare const allConfigs: Config[];
+/** Output paths for CSS and SCSS files */
+export declare const dimensionOutputPaths: OutPutFilesPaths;
+export default allConfigs;

package/types/configs/expressive/expressive.format.d.ts

@@ -0,0 +1,11 @@
+import { Named, Format } from 'style-dictionary';
+import { CssVarsFormatters } from '../../utils';
+/**
+ * Formatter to generate CSS variables for color tokens.
+ */
+export declare const expressiveColorFormatter: Named<Format>;
+/**
+ * All formatters for color tokens.
+ */
+export declare const expressiveFormatters: CssVarsFormatters;
+export default expressiveFormatters;

package/types/configs/expressive/index.d.ts

@@ -0,0 +1,3 @@
+import { BuildConfig } from '../../utils';
+export * from './sd.expressive.config';
+export declare const expressiveColorBuildConfig: BuildConfig;

package/types/configs/expressive/sd.expressive.config.d.ts

@@ -0,0 +1,6 @@
+import { Config } from 'style-dictionary';
+import { OutPutFilesPaths, CommonConfig } from '../../utils';
+export declare const COMMON_CONFIG: CommonConfig;
+declare const ExpressiveConfigs: Config[];
+export declare const expressiveColorOutputPaths: OutPutFilesPaths;
+export default ExpressiveConfigs;

package/types/configs/index.d.ts

@@ -0,0 +1,7 @@
+import { BuildConfig, ThemeConfig } from '../utils';
+/**
+ * Type guard to check if a value is a BuildConfig.
+ */
+export declare const isBuildConfig: (value: unknown) => value is BuildConfig;
+export declare const AllThemes: ThemeConfig[];
+export default AllThemes;

package/types/configs/js/index.d.ts

@@ -0,0 +1,4 @@
+import { BuildConfig } from '../../utils';
+export * from './sd.js.config';
+export * from './js.transformers';
+export declare const jsBuildConfig: BuildConfig;

package/types/configs/js/js.formatters.d.ts

@@ -0,0 +1,3 @@
+import { CssVarsFormatters } from '../../utils';
+export declare const jsFormatters: CssVarsFormatters;
+export default jsFormatters;

package/types/configs/js/js.transformers.d.ts

@@ -0,0 +1,10 @@
+import { Named, TransformGroup, Transform } from 'style-dictionary';
+import { TokenTransformers } from '../../utils';
+export declare const colorsCssProperty: Named<Transform>;
+export declare const dimensionsCssProperty: Named<Transform>;
+export declare const shadowsCssProperty: Named<Transform>;
+export declare const removeAttributes: Named<Transform>;
+export declare const tokenCssNameAsValue: Named<Transform>;
+export declare const jsTransformGroup: Named<TransformGroup>;
+export declare const jsTransformers: TokenTransformers;
+export default jsTransformers;

package/types/configs/js/js.utils.d.ts

@@ -0,0 +1,2 @@
+import { TransformedToken } from 'style-dictionary';
+export declare const tokenCssProperty: (token: TransformedToken, attribute: string) => boolean;

package/types/configs/js/sd.js.config.d.ts

@@ -0,0 +1,6 @@
+import { Config } from 'style-dictionary';
+import { OutPutFilesPaths } from '../../utils';
+export declare const jsStyleDictConfig: Config;
+export declare const allConfigs: Config[];
+export declare const jsOutputPaths: OutPutFilesPaths;
+export default allConfigs;

package/types/configs/language/formatters/css.d.ts

@@ -0,0 +1,17 @@
+import { Named, Format, TransformedToken } from 'style-dictionary';
+import { CssVarsFormatters } from '../../../utils';
+type TypoTokenFormatterHelper = (params: {
+    dictionary: TransformedToken[];
+}) => string;
+export declare const createCssAttributeVars: TypoTokenFormatterHelper;
+/**
+ * This formatter is used to generate css variables for colors
+ * @param {StyleDictionary.Dictionary} dictionary - The style dictionary dictionary object
+ * @param {StyleDictionary.Options} options - optional formatter options
+ * @param {ClassName} options.className - the class name to use for the css variables
+ * @param {SupportedLanguages} options.languages - The languages to generate css for
+ * @param {boolean} options.disableComponent - disable component tokens
+ **/
+export declare const typographyLanguageFormatter: Named<Format>;
+declare const typographyLanguageFormatters: CssVarsFormatters;
+export default typographyLanguageFormatters;

package/types/configs/language/formatters/index.d.ts

@@ -0,0 +1,3 @@
+import { CssVarsFormatters } from '../../../utils';
+export declare const typographyFormatters: CssVarsFormatters;
+export default typographyFormatters;

package/types/configs/language/index.d.ts

@@ -0,0 +1,6 @@
+import { BuildConfig, SupportedLanguages, ThemeConfig } from '../../utils';
+export * from './formatters';
+export * from './sd.language.config';
+export * from './transformers';
+export declare const languageBuildConfig: BuildConfig;
+export declare const languageThemeConfig: (theme: ThemeConfig, languages: SupportedLanguages[]) => BuildConfig;

package/types/configs/language/sd.language.config.d.ts

@@ -0,0 +1,7 @@
+import { Config } from 'style-dictionary';
+import { OutPutFilesPaths, CommonConfig } from '../../utils';
+export declare const tokenFilter: (token: import('style-dictionary').TransformedToken) => boolean;
+export declare const COMMON_CONFIG: CommonConfig;
+declare const allConfigs: Config[];
+export declare const languageOutputPaths: OutPutFilesPaths;
+export default allConfigs;

package/types/configs/language/transformers/attribute.d.ts

@@ -0,0 +1,10 @@
+import { Named, Transform } from 'style-dictionary';
+export declare const languageTokenCssName: Named<Transform>;
+/**
+ * This transformer is used to add clamp attributes to responsive headings
+ * so that they can be used in the css output
+ * @todo Move this logic to the scaling of the theme files phase of the code?
+ *  - What about the viasat theme where we don't scan and we jsut build directly.
+ *  - I guess no need since we control the configs by hand
+ */
+export declare const languageAttributes: Named<Transform>;

package/types/configs/language/transformers/index.d.ts

@@ -0,0 +1,5 @@
+import { Named, TransformGroup } from 'style-dictionary';
+import { TokenTransformers } from '../../../utils';
+export declare const languageTransformGroup: Named<TransformGroup>;
+export declare const languageTransformers: TokenTransformers;
+export default languageTransformers;

package/types/configs/product-type/index.d.ts

@@ -0,0 +1,5 @@
+import { BuildConfig } from '../../utils';
+export * from './product-type.format.css';
+export * from './sd.product-tokens.config';
+export * from './product-type.transformers';
+export declare const productTypeBuildConfig: BuildConfig;

package/types/configs/product-type/product-type.format.css.d.ts

@@ -0,0 +1,8 @@
+import { Named, Format } from 'style-dictionary';
+import { CssVarsFormatters } from '../../utils';
+/**
+ * Formatter to generate CSS variables for product type themes.
+ **/
+export declare const dimensionCssVarsFormatter: Named<Format>;
+export declare const productTypeFormatters: CssVarsFormatters;
+export default productTypeFormatters;

package/types/configs/product-type/product-type.transformers.d.ts

@@ -0,0 +1,2 @@
+export declare const productTypeTransformers: import('../../utils').TokenTransformers;
+export default productTypeTransformers;

package/types/configs/product-type/sd.product-tokens.config.d.ts

@@ -0,0 +1,7 @@
+import { Config } from 'style-dictionary';
+import { OutPutFilesPaths } from '../../utils';
+export declare const enterpriseStyleDictConfig: Config;
+export declare const consumerStyleDictConfig: Config;
+declare const allConfigs: Config[];
+export declare const productTypeOutputPaths: OutPutFilesPaths;
+export default allConfigs;

package/types/configs/shadows/index.d.ts

@@ -0,0 +1,7 @@
+import { BuildConfig, CssVarsFormatters, ThemeConfig } from '../../utils';
+export * from './sd.shadow.config';
+export * from './shadows.format.css';
+export * from './shadow.transformers';
+export declare const shadowFormatters: CssVarsFormatters;
+export declare const shadowBuildConfig: BuildConfig;
+export declare const ShadowThemeConfig: (theme: ThemeConfig) => BuildConfig;

package/types/configs/shadows/sd.shadow.config.d.ts

@@ -0,0 +1,9 @@
+import { Config, TransformedToken } from 'style-dictionary';
+import { OutPutFilesPaths, CommonConfig } from '../../utils';
+export declare const COMMON_CONFIG: CommonConfig;
+export declare const tokenFilter: (token: TransformedToken, darkMode?: boolean) => boolean;
+export declare const shadowStyleDictConfig: Config;
+export declare const darkShadowStyleDictConfig: Config;
+declare const ViasatConfig: Config[];
+export declare const shadowOutputPaths: OutPutFilesPaths;
+export default ViasatConfig;

package/types/configs/shadows/shadow.transformers.d.ts

@@ -0,0 +1,7 @@
+import { Named, Transform, TransformGroup } from 'style-dictionary';
+import { TokenTransformers } from '../../utils';
+export declare const parseGblTokenValue: Named<Transform>;
+export declare const parseSemTokenValue: Named<Transform>;
+export declare const dimensionTransformGroup: Named<TransformGroup>;
+export declare const shadowTransformers: TokenTransformers;
+export default shadowTransformers;

package/types/configs/shadows/shadows.format.css.d.ts

@@ -0,0 +1,8 @@
+import { Format, Named } from 'style-dictionary';
+import { CssVarsFormatters } from '../../utils';
+/**
+ * Formatter to generate CSS variables for shadow tokens.
+ **/
+export declare const shadowCssVarsFormatter: Named<Format>;
+declare const shadowCssVarsFormatters: CssVarsFormatters;
+export default shadowCssVarsFormatters;

package/types/configs/shadows/shadows.utils.d.ts

@@ -0,0 +1,11 @@
+import { TransformedToken } from 'style-dictionary';
+import { TOKEN_CATEGORY } from '../../utils';
+export declare const isShadowToken: (token: TransformedToken, category: TOKEN_CATEGORY) => boolean;
+export declare const parseShadowTokenValue: (token: TransformedToken) => {
+    bmValue: string;
+    category?: string;
+    type?: string;
+    item?: string;
+    subitem?: string;
+    state?: string;
+};

package/types/configs/storybook/index.d.ts

@@ -0,0 +1,4 @@
+import { BuildConfig } from '../../utils';
+export * from './sd.storybook.config';
+export * from './js.transformers';
+export declare const storybookBuildConfig: BuildConfig;

package/types/configs/storybook/js.formatters.d.ts

@@ -0,0 +1,3 @@
+import { CssVarsFormatters } from '../../utils';
+export declare const storyBookFormatters: CssVarsFormatters;
+export default storyBookFormatters;

package/types/configs/storybook/js.transformers.d.ts

@@ -0,0 +1,5 @@
+import { Named, TransformGroup } from 'style-dictionary';
+import { TokenTransformers } from '../../utils';
+export declare const storybookTransformGroup: Named<TransformGroup>;
+export declare const storybookTransformers: TokenTransformers;
+export default storybookTransformers;

package/types/configs/storybook/js.utils.d.ts

@@ -0,0 +1,2 @@
+import { TransformedToken } from 'style-dictionary';
+export declare const tokenCssProperty: (token: TransformedToken, attribute: string) => boolean;

package/types/configs/storybook/sd.storybook.config.d.ts

@@ -0,0 +1,6 @@
+import { Config } from 'style-dictionary';
+import { OutPutFilesPaths } from '../../utils';
+export declare const storybookStyleDictConfig: Config;
+export declare const allConfigs: Config[];
+export declare const storybookOutputPaths: OutPutFilesPaths;
+export default allConfigs;

package/types/configs/themes/generateThemes.d.ts

@@ -0,0 +1,2 @@
+import { ThemeConfig } from '../../utils';
+export declare const generateThemes: () => ThemeConfig[];

package/types/configs/themes/index.d.ts

@@ -0,0 +1 @@
+export * from './generateThemes';

package/types/configs/themes/sd.theme.config.d.ts

@@ -0,0 +1,3 @@
+import { Config } from 'style-dictionary';
+import { ThemeConfigurationGenerator } from '../../utils';
+export declare const createThemeConfigs: ({ theme, commonConfig, tokenFilter, languages, }: ThemeConfigurationGenerator) => Config[];

package/types/configs/themes/theme.utils.d.ts

@@ -0,0 +1,18 @@
+import { TokenOutputPaths, ThemeConfig } from '../../utils/constants';
+/**
+ * Checks if a theme contains a given token type.
+ * @param themeRootPath - The root path of the theme.
+ * @param tokenType - The type of token to check.
+ * @param tokenSearchString - An optional search string to refine the check.
+ * @returns True if the theme contains the token type.
+ */
+export declare const doesThemeHaveToken: ({ themeRootPath, tokenType, tokenSearchString, }: {
+    themeRootPath: string;
+    tokenType: keyof TokenOutputPaths;
+    tokenSearchString?: string | string[];
+}) => boolean;
+export declare const hasDarkTheme: (themeRootPath: string) => false | "dark";
+export declare const hasDimensionTokens: (themeRootPath: string, theme: ThemeConfig) => false | import('../../utils/constants').BuildConfig;
+export declare const hasShadowTokens: (themeRootPath: string, theme: ThemeConfig) => false | import('../../utils/constants').BuildConfig;
+export declare const hasTypographyTokens: (themeRootPath: string, theme: ThemeConfig) => false | import('../../utils/constants').BuildConfig;
+export declare const hasLanguageTokens: (themeRootPath: string, theme: ThemeConfig) => false | import('../../utils/constants').BuildConfig;

package/types/configs/typography/formatters/css.d.ts

@@ -0,0 +1,20 @@
+import { Named, Format, TransformedToken } from 'style-dictionary';
+import { CssVarsFormatters } from '../../../utils';
+type TypoTokenFormatterHelper = (params: {
+    dictionary: TransformedToken[];
+}) => string;
+export declare const createResponsiveHeadingClampCssVars: TypoTokenFormatterHelper;
+export declare const createTypographyFontClass: TypoTokenFormatterHelper;
+export declare const createTypographyFontShortHandCssVar: TypoTokenFormatterHelper;
+/**
+ * This formatter is used to generate css variables for colors
+ * @param {StyleDictionary.Dictionary} dictionary - The style dictionary dictionary object
+ * @param {StyleDictionary.Options} options - optional formatter options
+ * @param {ClassName} options.className - the class name to use for the css variables
+ * @param {boolean} options.includeRoot - include the :root selector in the output file
+ * @param {boolean} options.generateFontCss - generate css classes for typography fonts instead, for the purpose of importing into scss files
+ * @param {boolean} options.disableComponent - disable component tokens
+ **/
+export declare const typographyCssVarsFormatter: Named<Format>;
+declare const typographyCssVarsFormatters: CssVarsFormatters;
+export default typographyCssVarsFormatters;

package/types/configs/typography/formatters/index.d.ts

@@ -0,0 +1,3 @@
+import { CssVarsFormatters } from '../../../utils';
+export declare const typographyFormatters: CssVarsFormatters;
+export default typographyFormatters;

package/types/configs/typography/helpers.d.ts

@@ -0,0 +1,84 @@
+import { TransformedToken } from 'style-dictionary';
+import { CommonConfig } from '../../utils';
+export declare const COMMON_CONFIG: CommonConfig;
+/**
+ * These tokens are a special case that Figma and Token Studio do not support
+ * so we have to manually create them and their mappings
+ */
+export declare const responsiveHeadings: readonly ["6xl", "5xl", "4xl", "3xl", "2xl"];
+export type ResponsiveHeadings = typeof responsiveHeadings[number];
+export declare const responsiveHeadingsNoDots: string[];
+/**
+ * Default filter for typography tokens
+ *
+ * @param {TransformedToken} token
+ * @returns {boolean} true if token is a typography token
+ */
+export declare const filter: (token: TransformedToken) => boolean;
+/**
+ * Function that filters out the heading tokens that don't have `code` in the token name
+ * those tokens are just used for figma and not for code!
+ *
+ * @param {TransformedToken} token
+ * @returns {boolean} true if token is a typography token
+ */
+export declare const isNonCodeHeading: (token: TransformedToken) => boolean;
+/**
+ *
+ * Checks weather the original token JSON is a typography token.
+ * This is a useful function to filter out the typography tokens
+ *
+ * @param {TransformedToken} token
+ * @returns {boolean} true if token is a typography token
+ */
+export declare const isTypographyTokenType: (token: TransformedToken) => boolean;
+/**
+ *
+ * These are all the Typography tokens that are not responsive headings
+ * or css properties
+ *
+ * @param {TransformedToken} token
+ * @returns {boolean} true if token is a typography token
+ */
+export declare const isTypographyToken: (token: TransformedToken) => boolean;
+/**
+ *
+ * Checks weather a token is a responsive heading token
+ *
+ * @param {TransformedToken} token
+ * @returns {boolean} true if token is a typography token
+ */
+export declare const isResponsiveHeading: (token: TransformedToken) => boolean;
+/**
+ *
+ * Checks weather a token is a typography css properties token such as
+ * fontFamilies, fontWeights, etc.
+ *
+ * @param {TransformedToken} token
+ * @returns {boolean} true if token is a typography token
+ */
+export declare const isTypographyCssProperties: (token: TransformedToken) => boolean;
+/**
+ *
+ * Checks weather a token is a paragraph indent token, these are special tokens
+ *
+ * @param {TransformedToken} token
+ * @returns {boolean} true if token is a typography token
+ */
+export declare const isParagraphIndentToken: (token: TransformedToken) => boolean;
+/**
+ *
+ * Checks weather a tokens has an original type of fontFamilies
+ *
+ * @param {TransformedToken} token
+ * @returns {boolean} true if token is a typography token
+ */
+export declare const isFontFamiliesToken: (token: TransformedToken) => boolean;
+/**
+ *
+ * Checks weather a tokens has an original type of fontWeights
+ *
+ * @param {TransformedToken} token
+ * @returns {boolean} true if token is a typography token
+ */
+export declare const isFontWeightsToken: (token: TransformedToken) => boolean;

package/types/configs/typography/index.d.ts

@@ -0,0 +1,6 @@
+import { BuildConfig, ThemeConfig } from '../../utils';
+export * from './formatters';
+export * from './sd.typography.config';
+export * from './transformers';
+export declare const typographyBuildConfig: BuildConfig;
+export declare const typographyThemeConfig: (theme: ThemeConfig) => BuildConfig;

package/types/configs/typography/sd.typography.config.d.ts

@@ -0,0 +1,5 @@
+import { Config } from 'style-dictionary';
+import { OutPutFilesPaths } from '../../utils';
+declare const allConfigs: Config[];
+export declare const typographyOutputPaths: OutPutFilesPaths;
+export default allConfigs;

package/types/configs/typography/transformers/attribute.d.ts

@@ -0,0 +1,16 @@
+import { Named, Transform } from 'style-dictionary';
+export declare const typographyTokenCssName: Named<Transform>;
+type ClampAttribute = 'min' | 'max' | 'value';
+export type ClampAttributesObj = Record<ClampAttribute, string>;
+export type ClampCssVarsAttributes = {
+    name: string;
+    min: Record<string, string>;
+    max: Record<string, string>;
+    value: Record<string, string>;
+};
+/**
+ * This transformer is used to add clamp attributes to responsive headings
+ * so that they can be used in the css output
+ */
+export declare const responsiveHeadingsClampAttributes: Named<Transform>;
+export {};

package/types/configs/typography/transformers/index.d.ts

@@ -0,0 +1,5 @@
+import { Named, TransformGroup } from 'style-dictionary';
+import { TokenTransformers } from '../../../utils';
+export declare const typographyTransformGroup: Named<TransformGroup>;
+export declare const typographyTransformers: TokenTransformers;
+export default typographyTransformers;