@viasat/beam-tokens 2.0.0

package/types/utils/build-tokens.d.ts

@@ -0,0 +1 @@
+export {};

package/types/utils/constants/class-names.d.ts

@@ -0,0 +1,19 @@
+import { ClassName } from './types';
+export declare const DEFAULT_BRAND = "beam";
+export declare const BEAM_PREFIX = "bm";
+export declare const BEAM_LIGHT_THEME = "bm-light";
+export declare const BEAM_DARK_THEME = "bm-dark";
+export declare const BEAM_CONSUMER_THEME = "bm-consumer";
+export declare const BEAM_ENTERPRISE_THEME = "bm-enterprise";
+export declare const BEAM_LANGUAGE_PREFIX = "bm-lang";
+export declare const BEAM_EXPRESSIVE_PREFIX = "bm-expressive";
+export declare const BEAM_INVERSE_PREFIX = "bm-inverse";
+export declare const BEAM_PREFIX_REGEX: RegExp;
+export declare const BEAM_LIGHT_THEME_CLASS_OBJ: ClassName;
+export declare const BEAM_LIGHT_INVERSE_THEME_CLASS_OBJ: ClassName;
+export declare const BEAM_DARK_THEME_CLASS_OBJ: ClassName;
+export declare const BEAM_DARK_INVERSE_THEME_CLASS_OBJ: ClassName;
+export declare const BEAM_LIGHT_AND_DARK_THEME_CLASS_OBJ: ClassName;
+export declare const BEAM_ENTERPRISE_THEME_CLASS_OBJ: ClassName;
+export declare const BEAM_CONSUMER_THEME_CLASS_OBJ: ClassName;
+export declare const CLASS_NAME: ClassName;

package/types/utils/constants/index.d.ts

@@ -0,0 +1,7 @@
+export * from './class-names';
+export * from './math';
+export * from './paths';
+export * from './token-types';
+export * from './theme';
+export * from './types';
+export * from './typography';

package/types/utils/constants/math.d.ts

@@ -0,0 +1 @@
+export declare const MATH_SYMBOLS: readonly ["*", "/"];

package/types/utils/constants/paths.d.ts

@@ -0,0 +1,27 @@
+export declare const TOKEN_ROOT_PATH: string;
+export declare const LIB_ROOT_PATH: string;
+export declare const tailwindRootPath: string;
+export declare const ACCENT_THEMES_ROOT_PATH: string;
+export declare const BRAND_THEMES_ROOT_PATH: string;
+export declare const COMP_TOKEN_PATH: string;
+export declare const EXPRESSIVE_TOKEN_PATH: string;
+export declare const DEFAULT_TOKENS_FILE_NAME = "tokens";
+export declare const TOKEN_FILE_NAMES: {
+    readonly primitive: "primitives.json";
+    readonly sem: "semantic.json";
+    readonly comp: readonly ["components.json", "light.json", "dark.json"];
+    readonly light: "light.json";
+    readonly dark: "dark.json";
+    readonly theme: "theme.json";
+    readonly color: readonly ["light.json", "dark.json", "opacity.json", "theme.json"];
+    readonly dimension: readonly ["space.json", "size.json", "border-width.json", "radius.json", "components.json"];
+    readonly shadow: readonly ["light.json", "dark.json", "components.json"];
+    readonly typography: "typography.json";
+    readonly language: "typography.json";
+    readonly consumer: "consumer.json";
+    readonly enterprise: "enterprise.json";
+};
+export declare const LIGHT_MODE_SOURCE: string[];
+export declare const DARK_MODE_SOURCE: string[];
+export declare const ENTERPRISE_SOURCE: string[];
+export declare const CONSUMER_SOURCE: string[];

package/types/utils/constants/theme.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Color themes we support
+ */
+export declare const BASE_COLOR_THEMES: {
+    readonly light: "light";
+    readonly dark: "dark";
+};
+/**
+ * Shapes themes we support
+ */
+export declare const BASE_SHAPE_THEMES: {
+    readonly consumer: "consumer";
+    readonly enterprise: "enterprise";
+};
+/**
+ * Language that are supported. Update this list as needed
+ */
+export declare const SUPPORTED_LANGUAGE_CODES: {
+    readonly ar: "ar";
+    readonly he: "he";
+    readonly ja: "ja";
+    readonly zh: "zh";
+};
+export declare const SUPPORT_LANGUAGES: ("ar" | "he" | "ja" | "zh")[];

package/types/utils/constants/token-types.d.ts

@@ -0,0 +1,48 @@
+import { TOKEN_CATEGORY } from './types';
+export declare const TOKEN_CATEGORIES_SEM: {
+    readonly sem: "sem";
+    readonly utility: "utility";
+    readonly expressive: "expressive";
+    readonly theme: "theme";
+    readonly dataviz: "dataviz";
+};
+/**
+ * The top level token categories we support. These come right after
+ * the `bm` prefix
+ * @example primitive, sem, comp, utility, etc.
+ */
+export declare const TOKEN_CATEGORIES: {
+    readonly comp: "comp";
+    readonly sem: "sem";
+    readonly utility: "utility";
+    readonly expressive: "expressive";
+    readonly theme: "theme";
+    readonly dataviz: "dataviz";
+    readonly primitive: "primitive";
+};
+/**
+ * The top level token categories we support with `bm` prefix
+ * @example bm-primitive, bm-sem, bm-comp, bm-utility, etc.
+ */
+export declare const TOKEN_CATEGORIES_PREFIXED: Record<TOKEN_CATEGORY, string>;
+export declare const SUPPORTED_TOKEN_TYPES: {
+    readonly color: "color";
+    readonly dimension: "dimension";
+    readonly js: "js";
+    readonly language: "language";
+    readonly productType: "productType";
+    readonly typography: "typography";
+    readonly shadow: "shadow";
+    readonly expressive: "expressive";
+};
+export declare const EXPRESSIVE_THEMES: {
+    readonly accent: "accent";
+    readonly blue: "blue";
+    readonly gray: "gray";
+    readonly green: "green";
+    readonly orange: "orange";
+    readonly pink: "pink";
+    readonly red: "red";
+    readonly teal: "teal";
+    readonly violet: "violet";
+};

package/types/utils/constants/types.d.ts

@@ -0,0 +1,114 @@
+import { Config, Format, Named, Platform, Transform, TransformGroup, File, TransformedToken } from 'style-dictionary';
+import { TOKEN_FILE_NAMES } from './paths';
+import { EXPRESSIVE_THEMES, SUPPORTED_TOKEN_TYPES, TOKEN_CATEGORIES } from './token-types';
+import { BASE_COLOR_THEMES, BASE_SHAPE_THEMES, SUPPORTED_LANGUAGE_CODES } from './theme';
+export type TOKEN_FILE_NAME_KEYS = keyof typeof TOKEN_FILE_NAMES;
+export type VALID_TOKEN_TYPES = keyof typeof SUPPORTED_TOKEN_TYPES;
+export type TOKEN_CATEGORY = keyof typeof TOKEN_CATEGORIES;
+/**
+ * Theming
+ */
+export type BaseColorTheme = typeof BASE_COLOR_THEMES[keyof typeof BASE_COLOR_THEMES];
+export type BaseShapeTheme = typeof BASE_SHAPE_THEMES[keyof typeof BASE_SHAPE_THEMES];
+export type SupportedLanguages = typeof SUPPORTED_LANGUAGE_CODES[keyof typeof SUPPORTED_LANGUAGE_CODES];
+export type ComponentTokenPaths = typeof TOKEN_FILE_NAMES[Extract<TOKEN_CATEGORY, 'comp'>];
+export type PrimitiveAndCompTokenCategories = Extract<TOKEN_CATEGORY, 'primitive' | 'comp'>;
+export type TokenOutputPaths = Record<TOKEN_FILE_NAME_KEYS | PrimitiveAndCompTokenCategories | BaseColorTheme, string | ComponentTokenPaths | TOKEN_FILE_NAME_KEYS[]>;
+export type ThemeConfig = Partial<{
+    [k in VALID_TOKEN_TYPES | PrimitiveAndCompTokenCategories]: boolean | BuildConfig;
+}> & {
+    brandName: string;
+    themeName: string;
+    themeRootPath: string;
+    colorThemes: BaseColorTheme[];
+    shapeThemes?: BaseShapeTheme[];
+    storybook?: BuildConfig;
+};
+export type ThemeConfigurationGenerator = {
+    theme: ThemeConfig;
+    commonConfig: CommonConfig;
+    tokenFilter: (token: TransformedToken) => boolean;
+    languages?: SupportedLanguages[];
+};
+export type ExpressThemes = typeof EXPRESSIVE_THEMES[keyof typeof EXPRESSIVE_THEMES];
+export type OrganizedThemes = Record<string, Record<VALID_TOKEN_TYPES, BuildConfig[]>>;
+/**
+ * SD.Configs
+ */
+export type CommonConfig = {
+    transformGroup: Platform['transformGroup'];
+    buildPath: Platform['buildPath'];
+    format: File['format'];
+    options?: Platform['options'];
+};
+export type CssVarsFormatters = Named<Format>[];
+export type TokenTransformers = {
+    transformGroup: Named<TransformGroup>;
+    transformers: Named<Transform>[];
+};
+export type OutPutFilesPaths = {
+    css?: string[];
+    scss?: string[];
+};
+export type BuildConfig = {
+    transformers: TokenTransformers;
+    formatters: CssVarsFormatters;
+    configs: Config[];
+    outputFilesPaths: OutPutFilesPaths;
+};
+export declare const shadowTypes: readonly ["dropShadow", "boxShadow", "innerShadow", "shadow"];
+export type ShadowType = typeof shadowTypes[number];
+export type ShadowTokenValue = {
+    x: string;
+    y: string;
+    blur: string;
+    spread: string;
+    color: string;
+    type?: ShadowType;
+};
+export declare const colorTypes: readonly ["color", "gradient", "opacity"];
+export type ColorType = typeof colorTypes[number];
+export declare const dimensionTypes: readonly ["dimension", "space", "radius", "size", "border-width"];
+export type DimensionType = typeof dimensionTypes[number];
+export declare const utilityTypes: readonly ["utility", "other", "number"];
+export type UtilityType = typeof utilityTypes[number];
+export declare const tokenTypes: readonly ["color", "gradient", "opacity", "dropShadow", "boxShadow", "innerShadow", "shadow", "dimension", "space", "radius", "size", "border-width", "utility", "other", "number", "typography", ...("fontFamilies" | "fontWeights" | "lineHeights" | "letterSpacing" | "paragraphSpacing" | "textCase" | "textDecoration" | "fontSizes")[]];
+export type TokenType = typeof tokenTypes[number];
+export type ClassName = {
+    /**
+     * The base Beam theme
+     * @example bm-light bm-dark
+     */
+    base?: string;
+    /**
+     * Brand specific class name
+     * @example bm-onefi
+     */
+    brand?: string;
+    /**
+     * Sub brand specific class name
+     * @example bm-onefi-starlux bm-onefi-rja
+     */
+    subBrand?: string;
+    /**
+     * Language specific class name
+     * @example bm-lang-en bm-lang-es
+     */
+    lang?: string;
+};
+/**
+ * Represents the number of occurrences for each token category.
+ *
+ * This type is used to keep track of how many times each token category appears.
+ *
+ * @example
+ * const occurrences: OccurrenceCounts = {
+ *   primitive: 2,
+ *   sem: 1,
+ *   utility: 0,
+ *   comp: 3,
+ *   expressive: 0,
+ *   theme: 1,
+ * };
+ */
+export type OccurrenceCounts = Record<TOKEN_CATEGORY, number>;

package/types/utils/constants/typography.d.ts

@@ -0,0 +1,39 @@
+export declare const FONT_WEIGHT: {
+    readonly Thin: "100";
+    readonly ExtraLight: "200";
+    readonly UltraLight: "200";
+    readonly Light: "300";
+    readonly Book: "350";
+    readonly Normal: "400";
+    readonly Regular: "400";
+    readonly Roman: "400";
+    readonly Medium: "500";
+    readonly SemiBold: "600";
+    readonly DemiBold: "600";
+    readonly Bold: "700";
+    /**
+     * This should probably be '900' however we
+     * control the font definitions in our @font-faces
+     * so it's not a problem... Unless someone loads
+     * our fonts with a different definition.
+     */
+    readonly Heavy: "800";
+    readonly ExtraBold: "800";
+    readonly UltraBold: "800";
+    readonly Black: "900";
+    readonly Italic: "italic";
+};
+export type Font_Weights = keyof typeof FONT_WEIGHT;
+export declare const TYPO_CSS_ATTRIBUTES: {
+    readonly fontFamilies: "fontFamilies";
+    readonly fontWeights: "fontWeights";
+    readonly lineHeights: "lineHeights";
+    readonly letterSpacing: "letterSpacing";
+    readonly paragraphSpacing: "paragraphSpacing";
+    readonly textCase: "textCase";
+    readonly textDecoration: "textDecoration";
+    readonly fontSizes: "fontSizes";
+};
+export type Typo_Css_Attributes = typeof TYPO_CSS_ATTRIBUTES[keyof typeof TYPO_CSS_ATTRIBUTES];
+export declare const TYPO_TOKENS: readonly ["typography", ...("fontFamilies" | "fontWeights" | "lineHeights" | "letterSpacing" | "paragraphSpacing" | "textCase" | "textDecoration" | "fontSizes")[]];
+export type Typo_Tokens = typeof TYPO_TOKENS[number];

package/types/utils/dataviz.d.ts

@@ -0,0 +1,68 @@
+export declare const DatavizGradients: {
+    SequentialOpt1: {
+        0: string;
+        14: string;
+        28: string;
+        42: string;
+        56: string;
+        70: string;
+        84: string;
+        100: string;
+    };
+    DivergingOpt1: {
+        0: string;
+        10: string;
+        20: string;
+        30: string;
+        40: string;
+        50: string;
+        60: string;
+        70: string;
+        80: string;
+        90: string;
+        100: string;
+    };
+    DivergingOpt2: {
+        0: string;
+        10: string;
+        20: string;
+        30: string;
+        40: string;
+        50: string;
+        60: string;
+        70: string;
+        80: string;
+        90: string;
+        100: string;
+    };
+};
+export interface GetGradientColorValueProps {
+    /**
+     * Starting value of the data range
+     */
+    start: number;
+    /**
+     * Ending value of the data range
+     */
+    end: number;
+    /**
+     * Value between start and end to calculate the gradient color for
+     */
+    value: number;
+    /**
+     * True if result color is binned by color stop, false for actual linear gradient
+     */
+    binned: boolean;
+    /**
+     * The desired gradient style to use
+     */
+    gradientOption: keyof typeof DatavizGradients;
+}
+/**
+ * Given a start and end data range and a specific value, computes the appropriate
+ * color result as an RGB() string for the requested gradient option. Use binned = true
+ * to return the color stop closest to the given value, otherwise false for an
+ * interpolated result between the two closest color stops along the gradient.
+ */
+export declare const getGradientColorValue: ({ start, end, value, binned, gradientOption, }: GetGradientColorValueProps) => string | undefined;
+export declare const getValueAsPercent: (start: number, end: number, value: number) => number;

package/types/utils/files/cleanup.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Cleans directories in the library folder except for index.ts
+ * @param dirPath - Directory path to clean
+ */
+export declare const cleanLibsDir: (dirPath: string) => Promise<void>;
+/**
+ * Removes duplicate Sass variables from file content
+ * @param fileContent - SCSS file content with potential duplicates
+ * @returns Deduplicated content
+ */
+export declare const removeDuplicateSassVariables: (fileContent: string) => string;

package/types/utils/files/index.d.ts

@@ -0,0 +1,5 @@
+export * from './cleanup';
+export * from './merge';
+export * from './paths';
+export * from './scan';
+export * from './validate';

package/types/utils/files/merge.d.ts

@@ -0,0 +1,20 @@
+import { BuiltInParserName, CustomParser, LiteralUnion } from 'prettier';
+import { BuildConfig, VALID_TOKEN_TYPES } from '../constants/types';
+/**
+ * Merges multiple files into a single output file
+ * @param outputPaths - Array of paths to input files
+ * @param outPutPath - Path to the output file
+ * @param outPutType - Type of the output file for formatting
+ */
+export declare const mergeFiles: (outputPaths: string[] | undefined, outPutPath: string, outPutType: LiteralUnion<BuiltInParserName, string> | CustomParser | undefined) => Promise<void>;
+/**
+ * Merges output files for each brand and all SCSS files into single files
+ * @param groupedBuildConfigs - Grouped build configurations by brand and token type
+ */
+export declare const mergeOutputFiles: (groupedBuildConfigs: Record<string, Record<VALID_TOKEN_TYPES, BuildConfig[]>>) => Promise<void>;
+/**
+ * Merges light and dark component CSS files into single files
+ * Processes all files in parallel for better performance
+ * @param componentDir - Directory containing the temporary component files
+ */
+export declare const mergeComponentFiles: (componentDir: string) => Promise<void>;

package/types/utils/files/paths.d.ts

@@ -0,0 +1,25 @@
+import { Config } from 'style-dictionary';
+import { OutPutFilesPaths, BuildConfig, ThemeConfig, OrganizedThemes } from '../constants/types';
+/**
+ * Generates a list of output file paths from Style Dictionary configs
+ * @param configs - Array of Style Dictionary configurations
+ * @param fileType - File type to filter for (e.g., 'css', 'scss')
+ * @returns Array of file paths
+ */
+export declare const generateOutputFileList: (configs: Config[], fileType: string) => string[];
+/**
+ * Groups themes by brand, organizing configurations by token type
+ * @param themes - Array of theme configurations
+ * @returns Organized themes grouped by brand and token type
+ */
+export declare const groupThemesByBrand: (themes: ThemeConfig[]) => OrganizedThemes;
+/**
+ * Generates filtered output file paths based on build configurations
+ * @param buildConfigs - Array of build configurations
+ * @param brandName - Optional brand name to filter by
+ * @returns Filtered output paths for CSS and SCSS files
+ */
+export declare const generateFilteredOutputPaths: ({ buildConfigs, brandName, }: {
+    buildConfigs: BuildConfig[];
+    brandName?: string;
+}) => OutPutFilesPaths;

package/types/utils/files/scan.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Type definition for component metadata
+ */
+export interface ComponentInfo {
+    fileName: string;
+    tokenKey: string;
+}
+/**
+ * Checks if a directory contains subdirectories
+ * @param dirPath - Directory path to check
+ * @returns True if subdirectories exist
+ */
+export declare const hasSubDirectories: (dirPath: string) => boolean;
+/**
+ * Recursively retrieves theme directories
+ * @param source - Base directory to search
+ * @param parentPath - Relative path to append (used for recursion)
+ * @returns Array of theme directory paths
+ */
+export declare const getThemeDirectories: (source: string, parentPath?: string) => string[];
+/**
+ * Gets expressive theme files from a directory
+ * @param source - Directory containing expressive theme files
+ * @returns Array of file names
+ */
+export declare const getExpressiveThemeFiles: (source: string) => string[];
+/**
+ * Extracts the token key from a component JSON file
+ * @param filePath - Path to the component JSON file
+ * @returns The token key or null if not found
+ */
+export declare const extractTokenKeyFromFile: (filePath: string) => string | null;
+/**
+ * Scans the components directory and returns all component metadata
+ * @param componentsDir - Path to the components directory
+ * @returns Array of component information with fileName and tokenKey
+ */
+export declare const getComponentNames: (componentsDir: string) => ComponentInfo[];

package/types/utils/files/validate.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Checks if a file contains a specific substring
+ * @param filePath - Path to the file
+ * @param searchString - Substring to search for
+ * @returns True if the substring exists
+ */
+export declare const doesFileIncludeSubString: (filePath: string, searchString: string) => boolean;
+/**
+ * Checks if a JSON file is empty
+ * @param filePath - Path to the JSON file
+ * @returns True if the JSON is empty
+ */
+export declare const fileIsEmptyJson: (filePath: string) => boolean;

package/types/utils/formatters/className.d.ts

@@ -0,0 +1,13 @@
+import { BaseColorTheme, ClassName } from '../../utils/constants';
+/**
+ * Creates a theme class name object.
+ */
+export declare const createThemeClassNameObj: (colorTheme: BaseColorTheme, brandName: string, themeName: string) => ClassName;
+/**
+ * Generates a formatted CSS class selector string for themes.
+ */
+export declare const createThemeClassName: (classObj: ClassName) => string;
+/**
+ * Creates a theme attribute selector string for a given theme defined by the classObj.
+ */
+export declare const createThemeAttributeSelector: (classObj: ClassName) => string;

package/types/utils/formatters/format.css.d.ts

@@ -0,0 +1,19 @@
+import { TransformedToken, Dictionary, Options } from 'style-dictionary';
+import { TOKEN_CATEGORIES, TOKEN_CATEGORY } from '../constants';
+/**
+ * Generates CSS variables for a given set of tokens.
+ * @param dictionary - The list of transformed tokens.
+ * @returns A string of CSS variables.
+ */
+export declare const generateCssVariables: ({ dictionary, }: {
+    dictionary: TransformedToken[];
+}) => string;
+type testFilter = {
+    [TOKEN_CATEGORIES.sem]: TOKEN_CATEGORY[];
+};
+export declare const cssVariableFormatter: ({ dictionary, options, filter, }: {
+    dictionary: Dictionary;
+    options: Options;
+    filter: testFilter;
+}) => string;
+export {};

package/types/utils/formatters/format.scss.d.ts

@@ -0,0 +1,12 @@
+import { Format, Named, TransformedToken } from 'style-dictionary';
+import { CssVarsFormatters } from '../constants/types';
+export declare const createScssVariables: ({ dictionary, }: {
+    dictionary: TransformedToken[];
+}) => string;
+/**
+ * This formatter is used to generate scss variables for all Beam tokens
+ * @param {StyleDictionary.Dictionary} dictionary - The style dictionary dictionary object
+ * @param {StyleDictionary.Options} options - optional formatter options
+ **/
+export declare const scssVarsFormatter: Named<Format>;
+export declare const scssVarsFormatters: CssVarsFormatters;

package/types/utils/formatters/index.d.ts

@@ -0,0 +1,4 @@
+export * from './className';
+export * from './format.css';
+export * from './format.scss';
+export * from './token.utils.css';

package/types/utils/formatters/token.utils.css.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Some tokens have code in them to indicate that they are code tokens
+ * but we don't want that in the css class name
+ * @param tokenCssName
+ * @returns string - the tokenCssName without the code- prefix
+ */
+export declare const removeCodeFromTokenCssName: (tokenCssName: string) => string;
+/**
+ * Wraps a string in a CSS var wrapper.
+ * @param value
+ * @param fallback - Optional. If provided, adds a fallback value to the CSS variable. Defaults to undefined.
+ * @returns string - value wrapped in a CSS var
+ * @example var(--value)
+ */
+export declare const wrapInVar: (value: string, fallback?: string) => string;
+/**
+ * Generates a CSS attribute string.
+ *
+ * @param attr - The CSS attribute name.
+ * @param value - The value for the CSS attribute.
+ * @param wrapValue - Optional. If true, wraps the value in a CSS variable function. Defaults to true.
+ * @param fallback - Optional. If provided, adds a fallback value to the CSS attribute. Defaults to undefined.
+ * @returns The formatted CSS attribute string.
+ * @example attr: value;
+ * @example attr: var(--value);
+ */
+export declare const makeCssAttribute: (attr: string, value: string, wrapValue?: boolean, fallback?: string) => string;
+/**
+ * Generates a CSS variable attribute string.
+ *
+ * @param attr - The CSS attribute name.
+ * @param value - The value for the CSS attribute.
+ * @param wrapValue - Optional. If true, wraps the value in a CSS variable function. Defaults to true.
+ * @returns The formatted CSS attribute string.
+ * @example --attr: value;
+ * @example --attr: var(--value);
+ */
+export declare const makeCssVarAttribute: (attr: string, value: string, wrapValue?: boolean) => string;
+/**
+ * Converts a token name into a CSS variable format.
+ *
+ * @param tokenName - The raw token name to be formatted.
+ * @param delimiter - The character used to separate token name segments.
+ * @param base - The base namespace for the token.
+ * @param useCssVarWrapper - Whether to wrap the result in a CSS variable (`var(--tokenName)`).
+ * @param useRgbaWrapper - Whether to wrap the result in an RGBA function (`rgba(var(--tokenName))`).
+ * @param fallback - An optional fallback value for the CSS variable.
+ * @returns A formatted CSS variable name, optionally wrapped in `var()` or `rgba()`.
+ */
+export declare const convertTokenNameToCssVarFormat: (tokenName: string, delimiter: string, base: string, useCssVarWrapper?: boolean, useRgbaWrapper?: boolean, fallback?: string) => string;

package/types/utils/functions.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Capitalizes the first letter of a string
+ */
+export declare const lowerCaseFirstLetter: (string: string) => string;
+/**
+ * Removes the braces from a string
+ */
+export declare const stripBraces: (value: string) => string;
+/**
+ * Removes the parentheses from a string
+ */
+export declare const stripParentheses: (value: string) => string;
+export declare const stripApostrophe: (value: string) => string;

package/types/utils/index.d.ts

@@ -0,0 +1,8 @@
+export * from './constants';
+export * from './files';
+export * from './formatters';
+export * from './functions';
+export * from './occurrences';
+export * from './tokens';
+export * from './transformers';
+export * from './dataviz';

package/types/utils/occurrences.d.ts

@@ -0,0 +1,32 @@
+import { OccurrenceCounts } from './constants';
+/**
+ * Counts the number of occurrences of a string in another string.
+ * Uses word boundaries to ensure we match complete token segments, not substrings.
+ * For example, "comp" should not match inside "compact".
+ */
+export declare const numberOfOccurrence: (string: string, tokenValue: string) => number;
+/**
+ * Calculates the number of occurrences for each token type.
+ */
+export declare const calculateOccurrences: (tokenValue: string) => OccurrenceCounts;
+/**
+ * Checks if the occurrences represent a single occurrence.
+ */
+export declare const isSingleOccurrence: (occurrences: OccurrenceCounts) => {
+    isSingle: boolean;
+    values: number[];
+    onesCount: number;
+    zerosCount: number;
+};
+/**
+ * Checks if the occurrences represent multiple occurrences.
+ */
+export declare const isMultipleOccurrence: (occurrences: OccurrenceCounts) => boolean;
+/**
+ * Checks if the occurrences has a comp token that points to another comp token
+ */
+export declare const has2CompOccurrences: (occurrences: OccurrenceCounts) => boolean;
+/**
+ * Checks if the occurrences has a comp token and a utility token
+ */
+export declare const hasCompAndUtilityOccurrences: (occurrences: OccurrenceCounts) => boolean;