@primer/primitives 9.1.2 → 10.0.0-rc.0c3e84bf

package/dist/build/transformers/colorToHex.js

@@ -1,26 +1,24 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.colorToHex = void 0;
-const color2k_1 = require("color2k");
-const filters_1 = require("../filters");
-const getTokenValue_1 = require("./utilities/getTokenValue");
-const alpha_1 = require("./utilities/alpha");
+import { toHex } from 'color2k';
+import { isColor } from '../filters/index.js';
+import { getTokenValue } from './utilities/getTokenValue.js';
+import { alpha } from './utilities/alpha.js';
 /**
  * @description converts color tokens value to `hex6` or `hex8`
  * @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 `hex` string
  */
-exports.colorToHex = {
-    type: `value`,
+export const colorToHex = {
+    name: 'color/hex',
+    type: 'value',
     transitive: true,
-    matcher: filters_1.isColor,
-    transformer: (token) => {
+    filter: isColor,
+    transform: (token) => {
         var _a, _b;
         const alphaValue = (_a = token.alpha) !== null && _a !== void 0 ? _a : (_b = token.$extensions) === null || _b === void 0 ? void 0 : _b.alpha;
         if (alphaValue === null || alphaValue === undefined) {
-            return (0, color2k_1.toHex)((0, getTokenValue_1.getTokenValue)(token));
+            return toHex(getTokenValue(token));
         }
-        return (0, color2k_1.toHex)((0, alpha_1.alpha)((0, getTokenValue_1.getTokenValue)(token), alphaValue, token));
+        return toHex(alpha(getTokenValue(token), alphaValue, token));
     },
 };

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

@@ -1,8 +1,8 @@
-import type StyleDictionary from 'style-dictionary';
+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: StyleDictionary.Transform;
+export declare const colorToHexMix: Transform;

package/dist/build/transformers/colorToHexMix.js

@@ -1,25 +1,20 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.colorToHexMix = void 0;
-const color2k_1 = require("color2k");
-const filters_1 = require("../filters");
-const getTokenValue_1 = require("./utilities/getTokenValue");
-const mix_1 = __importDefault(require("./utilities/mix"));
+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
  */
-exports.colorToHexMix = {
-    type: `value`,
+export const colorToHexMix = {
+    name: 'color/hexMix',
+    type: 'value',
     transitive: true,
-    matcher: filters_1.isColorWithMix,
-    transformer: (token) => {
+    filter: isColorWithMix,
+    transform: (token) => {
         var _a, _b;
-        return (0, color2k_1.toHex)((0, mix_1.default)((0, getTokenValue_1.getTokenValue)(token), ((_a = token.mix) === null || _a === void 0 ? void 0 : _a.color) || (0, getTokenValue_1.getTokenValue)(token), ((_b = token.mix) === null || _b === void 0 ? void 0 : _b.weight) || 0));
+        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

@@ -1,8 +1,8 @@
-import type StyleDictionary from 'style-dictionary';
+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: StyleDictionary.Transform;
+export declare const colorToRgbAlpha: Transform;

package/dist/build/transformers/colorToRgbAlpha.js

@@ -1,22 +1,20 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.colorToRgbAlpha = void 0;
-const filters_1 = require("../filters");
-const alpha_1 = require("./utilities/alpha");
-const getTokenValue_1 = require("./utilities/getTokenValue");
+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
  */
-exports.colorToRgbAlpha = {
-    type: `value`,
+export const colorToRgbAlpha = {
+    name: 'color/rgbAlpha',
+    type: 'value',
     transitive: true,
-    matcher: filters_1.isColorWithAlpha,
-    transformer: (token) => {
+    filter: isColorWithAlpha,
+    transform: (token) => {
         if (token.alpha === null)
-            return (0, getTokenValue_1.getTokenValue)(token);
-        return (0, alpha_1.alpha)((0, getTokenValue_1.getTokenValue)(token), token.alpha, token);
+            return getTokenValue(token);
+        return alpha(getTokenValue(token), token.alpha, token);
     },
 };

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

@@ -1,8 +1,8 @@
-import type StyleDictionary from 'style-dictionary';
+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: StyleDictionary.Transform;
+export declare const colorToRgbaFloat: Transform;

package/dist/build/transformers/colorToRgbaFloat.js

@@ -1,34 +1,28 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.colorToRgbaFloat = void 0;
-const color2k_1 = require("color2k");
-const filters_1 = require("../filters");
-const getTokenValue_1 = require("./utilities/getTokenValue");
-const rgbaFloatToHex_1 = require("./utilities/rgbaFloatToHex");
-const mix_1 = __importDefault(require("./utilities/mix"));
-const hexToRgbaFloat_1 = require("./utilities/hexToRgbaFloat");
-const isRgbaFloat_1 = require("./utilities/isRgbaFloat");
-const toRgbaFloat = (token, alpha) => {
+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 = (0, getTokenValue_1.getTokenValue)(token);
+    let tokenValue = getTokenValue(token);
     let tokenMixColor = (_a = token.mix) === null || _a === void 0 ? void 0 : _a.color;
     // get hex value from color string
-    if ((0, isRgbaFloat_1.isRgbaFloat)(tokenValue)) {
-        tokenValue = (0, rgbaFloatToHex_1.rgbaFloatToHex)(tokenValue, false);
+    if (isRgbaFloat(tokenValue)) {
+        tokenValue = rgbaFloatToHex(tokenValue, false);
     }
-    if (tokenMixColor && (0, isRgbaFloat_1.isRgbaFloat)(tokenMixColor)) {
-        tokenMixColor = (0, rgbaFloatToHex_1.rgbaFloatToHex)(tokenMixColor, false);
+    if (tokenMixColor && isRgbaFloat(tokenMixColor)) {
+        tokenMixColor = rgbaFloatToHex(tokenMixColor, false);
     }
-    let hex = (0, color2k_1.toHex)(tokenValue);
+    let hex = toHex(tokenValue);
     // mix color with mix color and weight
     if (token.mix && token.mix.color && token.mix.weight) {
-        hex = (0, color2k_1.toHex)((0, mix_1.default)(tokenValue, tokenMixColor, token.mix.weight));
+        hex = toHex(mix(tokenValue, tokenMixColor, token.mix.weight));
     }
     // return color as RgbaFloat
-    return (0, hexToRgbaFloat_1.hexToRgbaFloat)(hex, alpha);
+    return hexToRgbaFloat(hex, alpha);
 };
 /**
  * @description converts color tokens rgba float with values from 0 - 1
@@ -36,14 +30,16 @@ const toRgbaFloat = (token, alpha) => {
  * @matcher matches all tokens of $type `color`
  * @transformer returns a `rgb` float object
  */
-exports.colorToRgbaFloat = {
-    type: `value`,
+export const colorToRgbaFloat = {
+    name: 'color/rgbaFloat',
+    type: 'value',
     transitive: true,
-    matcher: filters_1.isColor,
-    transformer: (token) => {
+    filter: isColor,
+    transform: (token) => {
+        const value = getTokenValue(token);
         // skip if value is already rgb float
-        if ((0, isRgbaFloat_1.isRgbaFloat)(token.value) && !('mix' in token) && !('alpha' in token))
-            return token.value;
+        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

@@ -1,8 +1,8 @@
-import type StyleDictionary from 'style-dictionary';
+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: StyleDictionary.Transform;
+export declare const dimensionToPixelUnitless: Transform;

package/dist/build/transformers/dimensionToPixelUnitless.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.dimensionToPixelUnitless = void 0;
-const filters_1 = require("../filters");
+import { isDimension } from '../filters/index.js';
 /**
  * @description base font size from options or 16
  * @param options
@@ -26,25 +23,27 @@ const hasUnit = (value, unit) => {
  * @matcher matches all tokens of $type `dimension`
  * @transformer returns a float number
  */
-exports.dimensionToPixelUnitless = {
-    type: `value`,
+export const dimensionToPixelUnitless = {
+    name: 'dimension/pixelUnitless',
+    type: 'value',
     transitive: true,
-    matcher: filters_1.isDimension,
-    transformer: (token, options) => {
-        const baseFont = getBasePxFontSize(options);
-        const floatVal = parseFloat(token.value);
+    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.value}' is not valid and cannot be transform to 'float' \n`);
+            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.value, 'rem')) {
+        if (hasUnit(token[valueProp], 'rem')) {
             return floatVal * baseFont;
         }
-        if (hasUnit(token.value, 'px')) {
+        if (hasUnit(token[valueProp], 'px')) {
             return floatVal;
         }
-        return token.value;
+        return token[valueProp];
     },
 };

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

@@ -1,8 +1,8 @@
-import type StyleDictionary from 'style-dictionary';
+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: StyleDictionary.Transform;
+export declare const dimensionToRem: Transform;

package/dist/build/transformers/dimensionToRem.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.dimensionToRem = void 0;
-const filters_1 = require("../filters");
+import { isDimension } from '../filters/index.js';
 /**
  * @description base font size from options or 16
  * @param options
@@ -26,21 +23,23 @@ const hasUnit = (value, unit) => {
  * @matcher matches all tokens of $type `dimension`
  * @transformer returns a `rem` string
  */
-exports.dimensionToRem = {
-    type: `value`,
+export const dimensionToRem = {
+    name: 'dimension/rem',
+    type: 'value',
     transitive: true,
-    matcher: filters_1.isDimension,
-    transformer: (token, options) => {
-        const baseFont = getBasePxFontSize(options);
-        const floatVal = parseFloat(token.value);
+    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.value}' is not valid and cannot be transform to 'rem' \n`);
+            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.value, 'rem') || hasUnit(token.value, 'em')) {
-            return token.value;
+        if (hasUnit(token[valueProp], 'rem') || hasUnit(token[valueProp], 'em')) {
+            return token[valueProp];
         }
         return `${floatVal / baseFont}rem`;
     },

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

@@ -1,8 +1,8 @@
-import type StyleDictionary from 'style-dictionary';
+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: StyleDictionary.Transform;
+export declare const dimensionToRemPxArray: Transform;

package/dist/build/transformers/dimensionToRemPxArray.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.dimensionToRemPxArray = void 0;
-const filters_1 = require("../filters");
+import { isDimension } from '../filters/index.js';
 /**
  * @description base font size from options or 16
  * @param options
@@ -26,20 +23,22 @@ const hasUnit = (value, unit) => {
  * @matcher matches all tokens of $type `dimension`
  * @transformer returns an array with the `rem` and `pixel` string
  */
-exports.dimensionToRemPxArray = {
-    type: `value`,
+export const dimensionToRemPxArray = {
+    name: 'dimension/remPxArray',
+    type: 'value',
     transitive: true,
-    matcher: filters_1.isDimension,
-    transformer: (token, options) => {
-        const baseFont = getBasePxFontSize(options);
-        const floatVal = parseFloat(token.value);
+    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.value}' is not valid and cannot be transform to 'rem' \n`);
+            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.value, 'rem') || hasUnit(token.value, 'em')) {
+        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

@@ -1,8 +1,8 @@
-import type StyleDictionary from 'style-dictionary';
+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: StyleDictionary.Transform;
+export declare const durationToCss: Transform;

package/dist/build/transformers/durationToCss.js

@@ -1,24 +1,23 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.durationToCss = void 0;
-const isDuration_1 = require("../filters/isDuration");
+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
  */
-exports.durationToCss = {
-    type: `value`,
+export const durationToCss = {
+    name: 'duration/css',
+    type: 'value',
     transitive: true,
-    matcher: isDuration_1.isDuration,
-    transformer: (token, _options) => {
+    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.value !== `string` || !token.value.endsWith(`ms`)) {
-            throw new Error(`duration token value must be a string with an "ms" unit`);
+        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.value.replace('ms', ''));
+        let value = parseInt(token[valueProp].replace('ms', ''));
         let unit = `ms`;
         if (value >= 1000) {
             value = value / 1000;

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

@@ -1,8 +1,8 @@
-import type StyleDictionary from 'style-dictionary';
+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: StyleDictionary.Transform;
+export declare const figmaAttributes: Transform;

package/dist/build/transformers/figmaAttributes.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.figmaAttributes = void 0;
 const figmaScopes = {
     all: ['ALL_SCOPES'],
     radius: ['CORNER_RADIUS'],
@@ -41,13 +38,14 @@ const getScopes = (scopes) => {
  * @matcher matches all tokens
  * @transformer returns ab object of figma attributes
  */
-exports.figmaAttributes = {
+export const figmaAttributes = {
+    name: 'figma/attributes',
     type: `attribute`,
-    transformer: (token, platform = {}) => {
+    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']) || {};
+        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.mode) || mode || 'default',
+            mode: modeOverride || ((_b = platform.options) === null || _b === void 0 ? void 0 : _b.mode) || 'default',
             collection,
             group: group || collection,
             scopes: getScopes(scopes),

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

@@ -1,15 +1,15 @@
-import type StyleDictionary from 'style-dictionary';
+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: StyleDictionary.TransformedToken, unitless?: boolean) => any;
+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: StyleDictionary.Transform;
-export declare const floatToPixelUnitless: StyleDictionary.Transform;
+export declare const floatToPixel: Transform;
+export declare const floatToPixelUnitless: Transform;

package/dist/build/transformers/floatToPixel.js

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.floatToPixelUnitless = exports.floatToPixel = exports.convertFloatToPixel = void 0;
-const filters_1 = require("../filters");
+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
  */
-const convertFloatToPixel = (token, unitless = false) => {
+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' ||
@@ -20,22 +17,23 @@ const convertFloatToPixel = (token, unitless = false) => {
     // return converted value
     return convertedValue === 0 ? 0 : unitless ? Math.round(convertedValue) : `${Math.round(convertedValue)}px`;
 };
-exports.convertFloatToPixel = convertFloatToPixel;
 /**
  * @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
  */
-exports.floatToPixel = {
-    type: `value`,
+export const floatToPixel = {
+    name: 'float/pixel',
+    type: 'value',
     transitive: true,
-    matcher: filters_1.isNumber,
-    transformer: (token) => (0, exports.convertFloatToPixel)(token),
+    filter: isNumber,
+    transform: (token) => convertFloatToPixel(token),
 };
-exports.floatToPixelUnitless = {
-    type: `value`,
+export const floatToPixelUnitless = {
+    name: 'float/pixelUnitless',
+    type: 'value',
     transitive: true,
-    matcher: filters_1.isNumber,
-    transformer: (token) => (0, exports.convertFloatToPixel)(token, true),
+    filter: isNumber,
+    transform: (token) => convertFloatToPixel(token, true),
 };

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

@@ -1,4 +1,4 @@
-import type StyleDictionary from 'style-dictionary';
+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
@@ -11,4 +11,4 @@ export declare const parseFontFamily: (value: unknown) => string;
  * @matcher matches all tokens of $type `fontFamily`
  * @transformer returns a string
  */
-export declare const fontFamilyToCss: StyleDictionary.Transform;
+export declare const fontFamilyToCss: Transform;