@primer/primitives 10.0.0-rc.367a0502 → 10.0.0-rc.d2acd2c0

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`)) {
+            throw new Error(`duration token value must be a string with an "ms" unit`);
+        }
+        // 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 { mode, 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.mode) || mode || '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;

package/dist/build/transformers/fontWeightToNumber.js

@@ -0,0 +1,50 @@
+import { isFontWeight } from '../filters/index.js';
+import { getTokenValue } from './utilities/getTokenValue.js';
+const fontWeightMatrix = {
+    '100': ['thin', 'hairline'],
+    '200': ['extra-light', 'ultra-light'],
+    '300': ['light'],
+    '400': ['normal', 'regular', 'book'],
+    '500': ['medium'],
+    '600': ['semi-bold', 'demi-bold'],
+    '700': ['bold'],
+    '800': ['extra-bold', 'ultra-bold'],
+    '900': ['black', 'heavy'],
+    '950': ['extra-black', 'ultra-black'],
+};
+export const parseFontWeight = (value) => {
+    // throw on anything but string and number
+    if (typeof value !== 'string' && typeof value !== 'number') {
+        throw new Error(`Invalid value ${value}, should be a number or fontWeight string`);
+    }
+    // valid string
+    if (typeof value === 'string') {
+        const key = Object.keys(fontWeightMatrix).find((k) => fontWeightMatrix[k].includes(value));
+        if (key !== undefined) {
+            return parseInt(key);
+        }
+    }
+    // if number as string
+    if (typeof value === 'string' && typeof parseInt(value) === 'number' && !isNaN(parseInt(value))) {
+        value = parseInt(value);
+    }
+    // return if valid numver
+    if (typeof value === 'number' && value > 0 && value <= 1000) {
+        return value;
+    }
+    // invalid value
+    throw new Error(`Invalid value ${value}, should be a number or fontWeight string`);
+};
+/**
+ * @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 const fontWeightToNumber = {
+    name: 'fontWeight/number',
+    type: 'value',
+    transitive: true,
+    filter: isFontWeight,
+    transform: (token) => parseFontWeight(getTokenValue(token)),
+};

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

@@ -0,0 +1,24 @@
+export { borderToCss } from './borderToCss.js';
+export { colorToHex } from './colorToHex.js';
+export { colorToHexMix } from './colorToHexMix.js';
+export { colorToRgbAlpha } from './colorToRgbAlpha.js';
+export { colorToRgbaFloat } from './colorToRgbaFloat.js';
+export { floatToPixel } from './floatToPixel.js';
+export { floatToPixelUnitless } from './floatToPixel.js';
+export { dimensionToRem } from './dimensionToRem.js';
+export { dimensionToRemPxArray } from './dimensionToRemPxArray.js';
+export { dimensionToPixelUnitless } from './dimensionToPixelUnitless.js';
+export { durationToCss } from './durationToCss.js';
+export { figmaAttributes } from './figmaAttributes.js';
+export { fontFamilyToCss } from './fontFamilyToCss.js';
+export { fontFamilyToFigma } from './fontFamilyToFigma.js';
+export { fontWeightToNumber } from './fontWeightToNumber.js';
+export { jsonDeprecated } from './jsonDeprecated.js';
+export { namePathToCamelCase } from './namePathToCamelCase.js';
+export { namePathToPascalCase } from './namePathToPascalCase.js';
+export { namePathToDotNotation } from './namePathToDotNotation.js';
+export { namePathToFigma } from './namePathToFigma.js';
+export { namePathToKebabCase } from './namePathToKebabCase.js';
+export { namePathToSlashNotation } from './namePathToSlashNotation.js';
+export { shadowToCss } from './shadowToCss.js';
+export { typographyToCss } from './typographyToCss.js';

package/dist/build/transformers/index.js

@@ -0,0 +1,24 @@
+export { borderToCss } from './borderToCss.js';
+export { colorToHex } from './colorToHex.js';
+export { colorToHexMix } from './colorToHexMix.js';
+export { colorToRgbAlpha } from './colorToRgbAlpha.js';
+export { colorToRgbaFloat } from './colorToRgbaFloat.js';
+export { floatToPixel } from './floatToPixel.js';
+export { floatToPixelUnitless } from './floatToPixel.js';
+export { dimensionToRem } from './dimensionToRem.js';
+export { dimensionToRemPxArray } from './dimensionToRemPxArray.js';
+export { dimensionToPixelUnitless } from './dimensionToPixelUnitless.js';
+export { durationToCss } from './durationToCss.js';
+export { figmaAttributes } from './figmaAttributes.js';
+export { fontFamilyToCss } from './fontFamilyToCss.js';
+export { fontFamilyToFigma } from './fontFamilyToFigma.js';
+export { fontWeightToNumber } from './fontWeightToNumber.js';
+export { jsonDeprecated } from './jsonDeprecated.js';
+export { namePathToCamelCase } from './namePathToCamelCase.js';
+export { namePathToPascalCase } from './namePathToPascalCase.js';
+export { namePathToDotNotation } from './namePathToDotNotation.js';
+export { namePathToFigma } from './namePathToFigma.js';
+export { namePathToKebabCase } from './namePathToKebabCase.js';
+export { namePathToSlashNotation } from './namePathToSlashNotation.js';
+export { shadowToCss } from './shadowToCss.js';
+export { typographyToCss } from './typographyToCss.js';

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

@@ -0,0 +1,8 @@
+import type { Transform } from 'style-dictionary/types';
+/**
+ * @description replaces tokens value with content of tokens `deprecated` property
+ * @type value transformer — [StyleDictionary.ValueTransform](https://github.com/amzn/style-dictionary/blob/main/types/Transform.d.ts)
+ * @matcher matches all tokens with a `deprecated` property
+ * @transformer returns `string` specified in `token.deprecated` or `null`
+ */
+export declare const jsonDeprecated: Transform;

package/dist/build/transformers/jsonDeprecated.js

@@ -0,0 +1,14 @@
+import { isDeprecated } from '../filters/index.js';
+/**
+ * @description replaces tokens value with content of tokens `deprecated` property
+ * @type value transformer — [StyleDictionary.ValueTransform](https://github.com/amzn/style-dictionary/blob/main/types/Transform.d.ts)
+ * @matcher matches all tokens with a `deprecated` property
+ * @transformer returns `string` specified in `token.deprecated` or `null`
+ */
+export const jsonDeprecated = {
+    name: 'json/deprecated',
+    type: 'value',
+    transitive: true,
+    filter: isDeprecated,
+    transform: (token) => typeof token.deprecated === 'string' ? token.deprecated.replace(/[{}]/g, '') : null,
+};

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

@@ -0,0 +1,8 @@
+import type { Transform } from 'style-dictionary/types';
+/**
+ * @description converts the [TransformedToken's](https://github.com/amzn/style-dictionary/blob/main/types/TransformedToken.d.ts) `.path` array to a camelCase string, preserves casing of parts
+ * @type name transformer — [StyleDictionary.NameTransform](https://github.com/amzn/style-dictionary/blob/main/types/Transform.d.ts)
+ * @matcher omitted to match all tokens
+ * @transformer returns `string` camelCase
+ */
+export declare const namePathToCamelCase: Transform;

package/dist/build/transformers/namePathToCamelCase.js

@@ -0,0 +1,12 @@
+import { toCamelCase } from '../utilities/index.js';
+/**
+ * @description converts the [TransformedToken's](https://github.com/amzn/style-dictionary/blob/main/types/TransformedToken.d.ts) `.path` array to a camelCase string, preserves casing of parts
+ * @type name transformer — [StyleDictionary.NameTransform](https://github.com/amzn/style-dictionary/blob/main/types/Transform.d.ts)
+ * @matcher omitted to match all tokens
+ * @transformer returns `string` camelCase
+ */
+export const namePathToCamelCase = {
+    name: 'name/pathToCamelCase',
+    type: 'name',
+    transform: (token, options) => toCamelCase([(options === null || options === void 0 ? void 0 : options.prefix) || '', ...token.path]),
+};

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

@@ -0,0 +1,8 @@
+import type { Transform } from 'style-dictionary/types';
+/**
+ * @description converts the [TransformedToken's](https://github.com/amzn/style-dictionary/blob/main/types/TransformedToken.d.ts) `.path` array to a dot.notation string
+ * @type name transformer — [StyleDictionary.NameTransform](https://github.com/amzn/style-dictionary/blob/main/types/Transform.d.ts)
+ * @matcher omitted to match all tokens
+ * @transformer returns `string` in dot.notation
+ */
+export declare const namePathToDotNotation: Transform;

package/dist/build/transformers/namePathToDotNotation.js

@@ -0,0 +1,31 @@
+import { upperCaseFirstCharacter } from '../utilities/index.js';
+/**
+ * camelCase
+ * @scope custom camelCase implementation should only be used within `name path to dot notation` transformer
+ * @description replaces space ` `, dash `-`, underscore `_` and plus `+` by camelCasing e.g. `camel-case` -> `camelCase`
+ * @param string
+ * @returns string
+ */
+const camelCase = (string) => {
+    return string
+        .split(/[\s-_+]+/g)
+        .map((stringPart, index) => (index === 0 ? stringPart : upperCaseFirstCharacter(stringPart)))
+        .join('');
+};
+/**
+ * @description converts the [TransformedToken's](https://github.com/amzn/style-dictionary/blob/main/types/TransformedToken.d.ts) `.path` array to a dot.notation string
+ * @type name transformer — [StyleDictionary.NameTransform](https://github.com/amzn/style-dictionary/blob/main/types/Transform.d.ts)
+ * @matcher omitted to match all tokens
+ * @transformer returns `string` in dot.notation
+ */
+export const namePathToDotNotation = {
+    name: 'name/pathToDotNotation',
+    type: 'name',
+    transform: (token, options) => {
+        return ([options === null || options === void 0 ? void 0 : options.prefix, ...token.path]
+            // remove undefined if exists
+            .filter((part) => typeof part === 'string' && part !== '@')
+            .map((part) => camelCase(part))
+            .join('.'));
+    },
+};