@primer/primitives 10.0.0-rc.fd912e08 → 10.1.0-rc.5ced3fe0

package/dist/build/transformers/colorToHexMix.d.ts

@@ -0,0 +1,8 @@
+import type { Transform } from 'style-dictionary/types';
+/**
+ * @description replaces tokens value with `hex8` color using the tokens `alpha` property to specify the value used for alpha
+ * @type value transformer — [StyleDictionary.ValueTransform](https://github.com/amzn/style-dictionary/blob/main/types/Transform.d.ts)
+ * @matcher matches all tokens of $type `color` with an `alpha` property
+ * @transformer returns `hex8` string
+ */
+export declare const colorToHexMix: Transform;

package/dist/build/transformers/colorToHexMix.js

@@ -0,0 +1,20 @@
+import { toHex } from 'color2k';
+import { isColorWithMix } from '../filters/index.js';
+import { getTokenValue } from './utilities/getTokenValue.js';
+import mix from './utilities/mix.js';
+/**
+ * @description replaces tokens value with `hex8` color using the tokens `alpha` property to specify the value used for alpha
+ * @type value transformer — [StyleDictionary.ValueTransform](https://github.com/amzn/style-dictionary/blob/main/types/Transform.d.ts)
+ * @matcher matches all tokens of $type `color` with an `alpha` property
+ * @transformer returns `hex8` string
+ */
+export const colorToHexMix = {
+    name: 'color/hexMix',
+    type: 'value',
+    transitive: true,
+    filter: isColorWithMix,
+    transform: (token) => {
+        var _a, _b;
+        return toHex(mix(getTokenValue(token), ((_a = token.mix) === null || _a === void 0 ? void 0 : _a.color) || getTokenValue(token), ((_b = token.mix) === null || _b === void 0 ? void 0 : _b.weight) || 0));
+    },
+};

package/dist/build/transformers/colorToRgbAlpha.d.ts

@@ -0,0 +1,8 @@
+import type { Transform } from 'style-dictionary/types';
+/**
+ * @description replaces tokens value with `rgba` color using the tokens `alpha` property to specify the value used for alpha
+ * @type value transformer — [StyleDictionary.ValueTransform](https://github.com/amzn/style-dictionary/blob/main/types/Transform.d.ts)
+ * @matcher matches all tokens of $type `color` with an `alpha` property
+ * @transformer returns `rgba` string
+ */
+export declare const colorToRgbAlpha: Transform;

package/dist/build/transformers/colorToRgbAlpha.js

@@ -0,0 +1,20 @@
+import { isColorWithAlpha } from '../filters/index.js';
+import { alpha } from './utilities/alpha.js';
+import { getTokenValue } from './utilities/getTokenValue.js';
+/**
+ * @description replaces tokens value with `rgba` color using the tokens `alpha` property to specify the value used for alpha
+ * @type value transformer — [StyleDictionary.ValueTransform](https://github.com/amzn/style-dictionary/blob/main/types/Transform.d.ts)
+ * @matcher matches all tokens of $type `color` with an `alpha` property
+ * @transformer returns `rgba` string
+ */
+export const colorToRgbAlpha = {
+    name: 'color/rgbAlpha',
+    type: 'value',
+    transitive: true,
+    filter: isColorWithAlpha,
+    transform: (token) => {
+        if (token.alpha === null)
+            return getTokenValue(token);
+        return alpha(getTokenValue(token), token.alpha, token);
+    },
+};

package/dist/build/transformers/colorToRgbaFloat.d.ts

@@ -0,0 +1,8 @@
+import type { Transform } from 'style-dictionary/types';
+/**
+ * @description converts color tokens rgba float with values from 0 - 1
+ * @type value transformer — [StyleDictionary.ValueTransform](https://github.com/amzn/style-dictionary/blob/main/types/Transform.d.ts)
+ * @matcher matches all tokens of $type `color`
+ * @transformer returns a `rgb` float object
+ */
+export declare const colorToRgbaFloat: Transform;

package/dist/build/transformers/colorToRgbaFloat.js

@@ -0,0 +1,46 @@
+import { toHex } from 'color2k';
+import { isColor } from '../filters/index.js';
+import { getTokenValue } from './utilities/getTokenValue.js';
+import { rgbaFloatToHex } from './utilities/rgbaFloatToHex.js';
+import mix from './utilities/mix.js';
+import { hexToRgbaFloat } from './utilities/hexToRgbaFloat.js';
+import { isRgbaFloat } from './utilities/isRgbaFloat.js';
+const toRgbaFloat = (token, alpha = undefined) => {
+    var _a;
+    let tokenValue = getTokenValue(token);
+    let tokenMixColor = (_a = token.mix) === null || _a === void 0 ? void 0 : _a.color;
+    // get hex value from color string
+    if (isRgbaFloat(tokenValue)) {
+        tokenValue = rgbaFloatToHex(tokenValue, false);
+    }
+    if (tokenMixColor && isRgbaFloat(tokenMixColor)) {
+        tokenMixColor = rgbaFloatToHex(tokenMixColor, false);
+    }
+    let hex = toHex(tokenValue);
+    // mix color with mix color and weight
+    if (token.mix && token.mix.color && token.mix.weight) {
+        hex = toHex(mix(tokenValue, tokenMixColor, token.mix.weight));
+    }
+    // return color as RgbaFloat
+    return hexToRgbaFloat(hex, alpha);
+};
+/**
+ * @description converts color tokens rgba float with values from 0 - 1
+ * @type value transformer — [StyleDictionary.ValueTransform](https://github.com/amzn/style-dictionary/blob/main/types/Transform.d.ts)
+ * @matcher matches all tokens of $type `color`
+ * @transformer returns a `rgb` float object
+ */
+export const colorToRgbaFloat = {
+    name: 'color/rgbaFloat',
+    type: 'value',
+    transitive: true,
+    filter: isColor,
+    transform: (token) => {
+        const value = getTokenValue(token);
+        // skip if value is already rgb float
+        if (isRgbaFloat(value) && !('mix' in token) && !('alpha' in token))
+            return value;
+        // convert hex or rgb values to rgba float
+        return toRgbaFloat(token, token.alpha);
+    },
+};

package/dist/build/transformers/cubicBezierToCss.d.ts

@@ -0,0 +1,8 @@
+import type { Transform } from 'style-dictionary/types';
+/**
+ * @description converts cubicBezeir tokens array value to a css cubic-bezier
+ * @type value transformer — [StyleDictionary.ValueTransform](https://github.com/amzn/style-dictionary/blob/main/types/Transform.d.ts)
+ * @matcher matches all tokens of $type `duration`
+ * @transformer returns a css cubic-bezier function
+ */
+export declare const cubicBezierToCss: Transform;

package/dist/build/transformers/cubicBezierToCss.js

@@ -0,0 +1,23 @@
+import { isCubicBezier } from '../filters/isCubicBezier.js';
+/**
+ * @description converts cubicBezeir tokens array value to a css cubic-bezier
+ * @type value transformer — [StyleDictionary.ValueTransform](https://github.com/amzn/style-dictionary/blob/main/types/Transform.d.ts)
+ * @matcher matches all tokens of $type `duration`
+ * @transformer returns a css cubic-bezier function
+ */
+export const cubicBezierToCss = {
+    name: 'cubicBezeir/css',
+    type: 'value',
+    transitive: true,
+    filter: isCubicBezier,
+    transform: (token, _config) => {
+        var _a;
+        const value = (_a = token.$value) !== null && _a !== void 0 ? _a : token.value;
+        // throw value of more or less than 4 items in array
+        if (value.length !== 4 || value.some((item) => typeof item !== 'number')) {
+            throw new Error(`Invalid cubicBezier token ${token.path.join('.')}, must be an array with 4 numbers, but got this instead: ${JSON.stringify(value)}`);
+        }
+        // return value
+        return `cubic-bezier(${value.join(',')})`;
+    },
+};

package/dist/build/transformers/dimensionToPixelUnitless.d.ts

@@ -0,0 +1,8 @@
+import type { Transform } from 'style-dictionary/types';
+/**
+ * @description converts dimension tokens value to pixel value without unit, ignores `em` as they are relative to the font size of the parent element
+ * @type value transformer — [StyleDictionary.ValueTransform](https://github.com/amzn/style-dictionary/blob/main/types/Transform.d.ts)
+ * @matcher matches all tokens of $type `dimension`
+ * @transformer returns a float number
+ */
+export declare const dimensionToPixelUnitless: Transform;

package/dist/build/transformers/dimensionToPixelUnitless.js

@@ -0,0 +1,49 @@
+import { isDimension } from '../filters/index.js';
+/**
+ * @description base font size from options or 16
+ * @param options
+ * @returns number
+ */
+const getBasePxFontSize = (options) => (options && options.basePxFontSize) || 16;
+/**
+ * @description checks if token value has a specific unit
+ * @param value token value
+ * @param unit unit string like px or value
+ * @returns boolean
+ */
+const hasUnit = (value, unit) => {
+    if (typeof value === 'number') {
+        return false;
+    }
+    return value.indexOf(unit) > -1;
+};
+/**
+ * @description converts dimension tokens value to pixel value without unit, ignores `em` as they are relative to the font size of the parent element
+ * @type value transformer — [StyleDictionary.ValueTransform](https://github.com/amzn/style-dictionary/blob/main/types/Transform.d.ts)
+ * @matcher matches all tokens of $type `dimension`
+ * @transformer returns a float number
+ */
+export const dimensionToPixelUnitless = {
+    name: 'dimension/pixelUnitless',
+    type: 'value',
+    transitive: true,
+    filter: isDimension,
+    transform: (token, config, options) => {
+        const valueProp = options.usesDtcg ? '$value' : 'value';
+        const baseFont = getBasePxFontSize(config);
+        const floatVal = parseFloat(token[valueProp]);
+        if (isNaN(floatVal)) {
+            throw new Error(`Invalid dimension token: '${token.path.join('.')}: ${token[valueProp]}' is not valid and cannot be transform to 'float' \n`);
+        }
+        if (floatVal === 0) {
+            return 0;
+        }
+        if (hasUnit(token[valueProp], 'rem')) {
+            return floatVal * baseFont;
+        }
+        if (hasUnit(token[valueProp], 'px')) {
+            return floatVal;
+        }
+        return token[valueProp];
+    },
+};

package/dist/build/transformers/dimensionToRem.d.ts

@@ -0,0 +1,8 @@
+import type { Transform } from 'style-dictionary/types';
+/**
+ * @description converts dimension tokens value to `rem`, ignores `em` as they are relative to the font size of the parent element
+ * @type value transformer — [StyleDictionary.ValueTransform](https://github.com/amzn/style-dictionary/blob/main/types/Transform.d.ts)
+ * @matcher matches all tokens of $type `dimension`
+ * @transformer returns a `rem` string
+ */
+export declare const dimensionToRem: Transform;

package/dist/build/transformers/dimensionToRem.js

@@ -0,0 +1,46 @@
+import { isDimension } from '../filters/index.js';
+/**
+ * @description base font size from options or 16
+ * @param options
+ * @returns number
+ */
+const getBasePxFontSize = (options) => (options && options.basePxFontSize) || 16;
+/**
+ * @description checks if token value has a specific unit
+ * @param value token value
+ * @param unit unit string like px or value
+ * @returns boolean
+ */
+const hasUnit = (value, unit) => {
+    if (typeof value === 'number') {
+        return false;
+    }
+    return value.indexOf(unit) > -1;
+};
+/**
+ * @description converts dimension tokens value to `rem`, ignores `em` as they are relative to the font size of the parent element
+ * @type value transformer — [StyleDictionary.ValueTransform](https://github.com/amzn/style-dictionary/blob/main/types/Transform.d.ts)
+ * @matcher matches all tokens of $type `dimension`
+ * @transformer returns a `rem` string
+ */
+export const dimensionToRem = {
+    name: 'dimension/rem',
+    type: 'value',
+    transitive: true,
+    filter: isDimension,
+    transform: (token, config, options) => {
+        const valueProp = options.usesDtcg ? '$value' : 'value';
+        const baseFont = getBasePxFontSize(config);
+        const floatVal = parseFloat(token[valueProp]);
+        if (isNaN(floatVal)) {
+            throw new Error(`Invalid dimension token: '${token.name}: ${token[valueProp]}' is not valid and cannot be transform to 'rem' \n`);
+        }
+        if (floatVal === 0) {
+            return '0';
+        }
+        if (hasUnit(token[valueProp], 'rem') || hasUnit(token[valueProp], 'em')) {
+            return token[valueProp];
+        }
+        return `${floatVal / baseFont}rem`;
+    },
+};

package/dist/build/transformers/dimensionToRemPxArray.d.ts

@@ -0,0 +1,8 @@
+import type { Transform } from 'style-dictionary/types';
+/**
+ * @description converts dimension tokens value to `rem`, ignores `em` as they are relative to the font size of the parent element
+ * @type value transformer — [StyleDictionary.ValueTransform](https://github.com/amzn/style-dictionary/blob/main/types/Transform.d.ts)
+ * @matcher matches all tokens of $type `dimension`
+ * @transformer returns an array with the `rem` and `pixel` string
+ */
+export declare const dimensionToRemPxArray: Transform;

package/dist/build/transformers/dimensionToRemPxArray.js

@@ -0,0 +1,46 @@
+import { isDimension } from '../filters/index.js';
+/**
+ * @description base font size from options or 16
+ * @param options
+ * @returns number
+ */
+const getBasePxFontSize = (options) => (options && options.basePxFontSize) || 16;
+/**
+ * @description checks if token value has a specific unit
+ * @param value token value
+ * @param unit unit string like px or value
+ * @returns boolean
+ */
+const hasUnit = (value, unit) => {
+    if (typeof value === 'number') {
+        return false;
+    }
+    return value.indexOf(unit) > -1;
+};
+/**
+ * @description converts dimension tokens value to `rem`, ignores `em` as they are relative to the font size of the parent element
+ * @type value transformer — [StyleDictionary.ValueTransform](https://github.com/amzn/style-dictionary/blob/main/types/Transform.d.ts)
+ * @matcher matches all tokens of $type `dimension`
+ * @transformer returns an array with the `rem` and `pixel` string
+ */
+export const dimensionToRemPxArray = {
+    name: 'dimension/remPxArray',
+    type: 'value',
+    transitive: true,
+    filter: isDimension,
+    transform: (token, config, options) => {
+        const valueProp = options.usesDtcg ? '$value' : 'value';
+        const baseFont = getBasePxFontSize(config);
+        const floatVal = parseFloat(token[valueProp]);
+        if (isNaN(floatVal)) {
+            throw new Error(`Invalid dimension token: '${token.name}: ${token[valueProp]}' is not valid and cannot be transform to 'rem' \n`);
+        }
+        if (floatVal === 0) {
+            return ['0', '0'];
+        }
+        if (hasUnit(token[valueProp], 'rem') || hasUnit(token[valueProp], 'em')) {
+            return [token.value, `${floatVal * baseFont}px`];
+        }
+        return [`${floatVal / baseFont}rem`, `${floatVal}px`];
+    },
+};

package/dist/build/transformers/durationToCss.d.ts

@@ -0,0 +1,8 @@
+import type { Transform } from 'style-dictionary/types';
+/**
+ * @description converts duration tokens string value to number with `ms` unit
+ * @type value transformer — [StyleDictionary.ValueTransform](https://github.com/amzn/style-dictionary/blob/main/types/Transform.d.ts)
+ * @matcher matches all tokens of $type `duration`
+ * @transformer returns a css duration
+ */
+export declare const durationToCss: Transform;

package/dist/build/transformers/durationToCss.js

@@ -0,0 +1,29 @@
+import { isDuration } from '../filters/index.js';
+/**
+ * @description converts duration tokens string value to number with `ms` unit
+ * @type value transformer — [StyleDictionary.ValueTransform](https://github.com/amzn/style-dictionary/blob/main/types/Transform.d.ts)
+ * @matcher matches all tokens of $type `duration`
+ * @transformer returns a css duration
+ */
+export const durationToCss = {
+    name: 'duration/css',
+    type: 'value',
+    transitive: true,
+    filter: isDuration,
+    transform: (token, _config, options) => {
+        const valueProp = options.usesDtcg ? '$value' : 'value';
+        // throw an error if token value is not a string or does not end with `ms`
+        if (typeof token[valueProp] !== `string` || !(token[valueProp].endsWith(`ms`) || token[valueProp].endsWith(`s`))) {
+            throw new Error(`duration token value must be a string with an "ms" || "s" unit, invalid token: ${token.name} with value: ${token[valueProp]}`);
+        }
+        // get value
+        let value = parseInt(token[valueProp].replace('ms', ''));
+        let unit = `ms`;
+        if (value >= 1000) {
+            value = value / 1000;
+            unit = `s`;
+        }
+        // return value
+        return `${value}${unit}`;
+    },
+};

package/dist/build/transformers/figmaAttributes.d.ts

@@ -0,0 +1,8 @@
+import type { Transform } from 'style-dictionary/types';
+/**
+ * @description retrieves figma attributes from token and adds them to attributes
+ * @type attribute transformer — [StyleDictionary.AttributeTransform](https://github.com/amzn/style-dictionary/blob/main/types/Transform.d.ts)
+ * @matcher matches all tokens
+ * @transformer returns ab object of figma attributes
+ */
+export declare const figmaAttributes: Transform;

package/dist/build/transformers/figmaAttributes.js

@@ -0,0 +1,55 @@
+const figmaScopes = {
+    all: ['ALL_SCOPES'],
+    radius: ['CORNER_RADIUS'],
+    size: ['WIDTH_HEIGHT'],
+    gap: ['GAP'],
+    bgColor: ['FRAME_FILL', 'SHAPE_FILL'],
+    fgColor: ['TEXT_FILL', 'SHAPE_FILL'],
+    effectColor: ['EFFECT_COLOR'],
+    effectFloat: ['EFFECT_FLOAT'],
+    borderColor: ['STROKE_COLOR'],
+    borderWidth: ['STROKE_FLOAT'],
+    opacity: ['OPACITY'],
+    fontFamily: ['FONT_FAMILY'],
+    fontStyle: ['FONT_STYLE'],
+    fontWeight: ['FONT_WEIGHT'],
+    fontSize: ['FONT_SIZE'],
+    lineHeight: ['LINE_HEIGHT'],
+    letterSpacing: ['LETTER_SPACING'],
+    paragraphSpacing: ['PARAGRAPH_SPACING'],
+    paragraphIndent: ['PARAGRAPH_INDENT'],
+};
+const getScopes = (scopes) => {
+    if (typeof scopes === 'string')
+        scopes = [scopes];
+    if (Array.isArray(scopes))
+        return scopes
+            .map(scope => {
+            if (scope in figmaScopes)
+                return figmaScopes[scope];
+            throw new Error(`Invalid scope: ${scope}`);
+        })
+            .flat();
+    return ['ALL_SCOPES'];
+};
+/**
+ * @description retrieves figma attributes from token and adds them to attributes
+ * @type attribute transformer — [StyleDictionary.AttributeTransform](https://github.com/amzn/style-dictionary/blob/main/types/Transform.d.ts)
+ * @matcher matches all tokens
+ * @transformer returns ab object of figma attributes
+ */
+export const figmaAttributes = {
+    name: 'figma/attributes',
+    type: `attribute`,
+    transform: (token, platform = {}) => {
+        var _a, _b;
+        const { modeOverride, collection, scopes, group, codeSyntax } = ((_a = token.$extensions) === null || _a === void 0 ? void 0 : _a['org.primer.figma']) || {};
+        return {
+            mode: ((_b = platform.options) === null || _b === void 0 ? void 0 : _b.theme) || modeOverride || 'default',
+            collection,
+            group: group || collection,
+            scopes: getScopes(scopes),
+            codeSyntax,
+        };
+    },
+};

package/dist/build/transformers/floatToPixel.d.ts

@@ -0,0 +1,15 @@
+import type { Transform, TransformedToken } from 'style-dictionary/types';
+/**
+ * takes a value and returns it if its a px string if it is a float and the token has a fontSize value in extensions['org.primer.data']
+ * @param value
+ * @returns string
+ */
+export declare const convertFloatToPixel: (token: TransformedToken, unitless?: boolean) => any;
+/**
+ * @description converts a float value to a pixel value based on the provided fontSize on the tokersn extension
+ * @type value transformer — [StyleDictionary.ValueTransform](https://github.com/amzn/style-dictionary/blob/main/types/Transform.d.ts)
+ * @matcher matches all tokens of $type `isNumber`
+ * @transformer returns a pixel string
+ */
+export declare const floatToPixel: Transform;
+export declare const floatToPixelUnitless: Transform;

package/dist/build/transformers/floatToPixel.js

@@ -0,0 +1,39 @@
+import { isNumber } from '../filters/index.js';
+/**
+ * takes a value and returns it if its a px string if it is a float and the token has a fontSize value in extensions['org.primer.data']
+ * @param value
+ * @returns string
+ */
+export const convertFloatToPixel = (token, unitless = false) => {
+    var _a, _b, _c, _d, _e, _f;
+    // short circut if value is not a number
+    if (typeof token.value !== 'number' ||
+        !((_b = (_a = token.$extensions) === null || _a === void 0 ? void 0 : _a['org.primer.data']) === null || _b === void 0 ? void 0 : _b.fontSize) ||
+        typeof ((_d = (_c = token.$extensions) === null || _c === void 0 ? void 0 : _c['org.primer.data']) === null || _d === void 0 ? void 0 : _d.fontSize) !== 'number') {
+        return token.value;
+    }
+    // convert value
+    const convertedValue = ((_f = (_e = token.$extensions) === null || _e === void 0 ? void 0 : _e['org.primer.data']) === null || _f === void 0 ? void 0 : _f.fontSize) * token.value;
+    // return converted value
+    return convertedValue === 0 ? 0 : unitless ? Math.round(convertedValue) : `${Math.round(convertedValue)}px`;
+};
+/**
+ * @description converts a float value to a pixel value based on the provided fontSize on the tokersn extension
+ * @type value transformer — [StyleDictionary.ValueTransform](https://github.com/amzn/style-dictionary/blob/main/types/Transform.d.ts)
+ * @matcher matches all tokens of $type `isNumber`
+ * @transformer returns a pixel string
+ */
+export const floatToPixel = {
+    name: 'float/pixel',
+    type: 'value',
+    transitive: true,
+    filter: isNumber,
+    transform: (token) => convertFloatToPixel(token),
+};
+export const floatToPixelUnitless = {
+    name: 'float/pixelUnitless',
+    type: 'value',
+    transitive: true,
+    filter: isNumber,
+    transform: (token) => convertFloatToPixel(token, true),
+};

package/dist/build/transformers/fontFamilyToCss.d.ts

@@ -0,0 +1,14 @@
+import type { Transform } from 'style-dictionary/types';
+/**
+ * takes a value and returns it if its a string or concats strings in an array quoting strings with spaces
+ * @param value
+ * @returns string
+ */
+export declare const parseFontFamily: (value: unknown) => string;
+/**
+ * @description converts fontFamily tokens value to string
+ * @type value transformer — [StyleDictionary.ValueTransform](https://github.com/amzn/style-dictionary/blob/main/types/Transform.d.ts)
+ * @matcher matches all tokens of $type `fontFamily`
+ * @transformer returns a string
+ */
+export declare const fontFamilyToCss: Transform;

package/dist/build/transformers/fontFamilyToCss.js

@@ -0,0 +1,37 @@
+import { isFontFamily } from '../filters/index.js';
+import { getTokenValue } from './utilities/getTokenValue.js';
+import { hasSpaceInString } from './utilities/hasSpaceInString.js';
+/**
+ * takes a value and returns it if its a string or concats strings in an array quoting strings with spaces
+ * @param value
+ * @returns string
+ */
+export const parseFontFamily = (value) => {
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value
+            .map((string) => {
+            if (typeof string !== 'string') {
+                throw new Error(`Invalid value in array ${string}, must be a string`);
+            }
+            return hasSpaceInString(string) ? `'${string}'` : string;
+        })
+            .join(', ');
+    }
+    throw new Error(`Invalid value ${value}, should be a string or array of strings`);
+};
+/**
+ * @description converts fontFamily tokens value to string
+ * @type value transformer — [StyleDictionary.ValueTransform](https://github.com/amzn/style-dictionary/blob/main/types/Transform.d.ts)
+ * @matcher matches all tokens of $type `fontFamily`
+ * @transformer returns a string
+ */
+export const fontFamilyToCss = {
+    name: 'fontFamily/css',
+    type: 'value',
+    transitive: true,
+    filter: isFontFamily,
+    transform: (token) => parseFontFamily(getTokenValue(token)),
+};

package/dist/build/transformers/fontFamilyToFigma.d.ts

@@ -0,0 +1,14 @@
+import type { Config, Transform, TransformedToken } from 'style-dictionary/types';
+/**
+ * takes a value and returns it if its a string or concats strings in an array quoting strings with spaces
+ * @param value
+ * @returns string
+ */
+export declare const parseFontFamily: (token: TransformedToken, fontFamilies: Record<string, string> | undefined, options: Config) => string;
+/**
+ * @description converts fontFamily tokens value to string
+ * @type value transformer — [StyleDictionary.ValueTransform](https://github.com/amzn/style-dictionary/blob/main/types/Transform.d.ts)
+ * @matcher matches all tokens of $type `fontFamily`
+ * @transformer returns a string
+ */
+export declare const fontFamilyToFigma: Transform;

package/dist/build/transformers/fontFamilyToFigma.js

@@ -0,0 +1,44 @@
+import { isFontFamily } from '../filters/index.js';
+import { hasSpaceInString } from './utilities/hasSpaceInString.js';
+/**
+ * takes a value and returns it if its a string or concats strings in an array quoting strings with spaces
+ * @param value
+ * @returns string
+ */
+export const parseFontFamily = (token, fontFamilies = {}, options) => {
+    const valueProp = options.usesDtcg ? '$value' : 'value';
+    // return value from fontFamilies
+    if (token.name in fontFamilies) {
+        return fontFamilies[token.name];
+    }
+    // return string
+    if (typeof token[valueProp] === 'string') {
+        return token[valueProp];
+    }
+    // return stringified array
+    if (Array.isArray(token[valueProp])) {
+        return token[valueProp]
+            .map((string) => {
+            if (typeof string !== 'string') {
+                throw new Error(`Invalid value in array ${string}, must be a string`);
+            }
+            return hasSpaceInString(string) ? `'${string}'` : string;
+        })
+            .join(', ');
+    }
+    // invalid value
+    throw new Error(`Invalid value ${token[valueProp]}, should be a string or array of strings`);
+};
+/**
+ * @description converts fontFamily tokens value to string
+ * @type value transformer — [StyleDictionary.ValueTransform](https://github.com/amzn/style-dictionary/blob/main/types/Transform.d.ts)
+ * @matcher matches all tokens of $type `fontFamily`
+ * @transformer returns a string
+ */
+export const fontFamilyToFigma = {
+    name: 'fontFamily/figma',
+    type: 'value',
+    transitive: true,
+    filter: isFontFamily,
+    transform: (token, platform, options) => { var _a; return parseFontFamily(token, (_a = platform.options) === null || _a === void 0 ? void 0 : _a.fontFamilies, options); },
+};

package/dist/build/transformers/fontWeightToNumber.d.ts

@@ -0,0 +1,9 @@
+import type { Transform } from 'style-dictionary/types';
+export declare const parseFontWeight: (value: unknown) => number;
+/**
+ * @description converts fontWeight tokens value to numeric value
+ * @type value transformer — [StyleDictionary.ValueTransform](https://github.com/amzn/style-dictionary/blob/main/types/Transform.d.ts)
+ * @matcher matches all tokens of $type `fontWeight`
+ * @transformer returns a number
+ */
+export declare const fontWeightToNumber: Transform;