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

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,25 @@
+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 { cubicBezierToCss } from './cubicBezierToCss.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,25 @@
+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 { cubicBezierToCss } from './cubicBezierToCss.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('.'));
+    },
+};

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

@@ -0,0 +1,9 @@
+import type { PlatformConfig, Transform, TransformedToken } from 'style-dictionary/types';
+export declare const transformNamePathToFigma: (token: TransformedToken, options?: PlatformConfig) => string;
+/**
+ * @description converts the [TransformedToken's](https://github.com/amzn/style-dictionary/blob/main/types/TransformedToken.d.ts) `.path` array to a specific figma name
+ * @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`
+ */
+export declare const namePathToFigma: Transform;

package/dist/build/transformers/namePathToFigma.js

@@ -0,0 +1,21 @@
+export const transformNamePathToFigma = (token, options) => {
+    let pathArray = token.path.filter((part) => part !== '@');
+    if (['fgColor', 'borderColor', 'bgColor'].includes(pathArray[0]) && pathArray.length === 3) {
+        pathArray = [pathArray[0], `${pathArray[1]}-${pathArray[2]}`];
+    }
+    return ([options === null || options === void 0 ? void 0 : options.prefix, ...pathArray]
+        // remove undefined if exists
+        .filter((part) => typeof part === 'string' && part !== '@')
+        .join('/'));
+};
+/**
+ * @description converts the [TransformedToken's](https://github.com/amzn/style-dictionary/blob/main/types/TransformedToken.d.ts) `.path` array to a specific figma name
+ * @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`
+ */
+export const namePathToFigma = {
+    name: 'name/pathToFigma',
+    type: 'name',
+    transform: transformNamePathToFigma,
+};

package/dist/build/transformers/namePathToKebabCase.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 kebab-case 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` kebab-case
+ */
+export declare const namePathToKebabCase: Transform;

package/dist/build/transformers/namePathToKebabCase.js

@@ -0,0 +1,16 @@
+/**
+ * @description converts the [TransformedToken's](https://github.com/amzn/style-dictionary/blob/main/types/TransformedToken.d.ts) `.path` array to a kebab-case 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` kebab-case
+ */
+export const namePathToKebabCase = {
+    name: 'name/pathToKebabCase',
+    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 !== '@')
+            .join('-'));
+    },
+};

package/dist/build/transformers/namePathToPascalCase.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 PascalCase 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` PascalCase
+ */
+export declare const namePathToPascalCase: Transform;

package/dist/build/transformers/namePathToPascalCase.js

@@ -0,0 +1,12 @@
+import { toPascalCase } 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 PascalCase 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` PascalCase
+ */
+export const namePathToPascalCase = {
+    name: 'name/pathToPascalCase',
+    type: 'name',
+    transform: (token, options) => toPascalCase([(options === null || options === void 0 ? void 0 : options.prefix) || '', ...token.path]),
+};

package/dist/build/transformers/namePathToSlashNotation.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 slash/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` on slash/notation
+ */
+export declare const namePathToSlashNotation: Transform;

package/dist/build/transformers/namePathToSlashNotation.js

@@ -0,0 +1,16 @@
+/**
+ * @description converts the [TransformedToken's](https://github.com/amzn/style-dictionary/blob/main/types/TransformedToken.d.ts) `.path` array to a slash/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` on slash/notation
+ */
+export const namePathToSlashNotation = {
+    name: 'name/pathToSlashNotation',
+    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 !== '@')
+            .join('/'));
+    },
+};

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

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

package/dist/build/transformers/shadowToCss.js

@@ -0,0 +1,34 @@
+import { toHex } from 'color2k';
+import { isShadow } from '../filters/index.js';
+import { alpha } from './utilities/alpha.js';
+import { checkRequiredTokenProperties } from './utilities/checkRequiredTokenProperties.js';
+import { getTokenValue } from './utilities/getTokenValue.js';
+/**
+ * @description converts w3c shadow tokens in css shadow string
+ * @type value transformer — [StyleDictionary.ValueTransform](https://github.com/amzn/style-dictionary/blob/main/types/Transform.d.ts)
+ * @matcher matches all tokens of $type `shadow`
+ * @transformer returns css shadow `string`
+ */
+export const shadowToCss = {
+    name: 'shadow/css',
+    type: 'value',
+    transitive: true,
+    filter: isShadow,
+    transform: (token) => {
+        // extract value
+        const value = getTokenValue(token);
+        const valueProp = token.$value ? '$value' : 'value';
+        // turn value into array
+        const shadowValues = !Array.isArray(value) ? [value] : value;
+        return shadowValues
+            .map((shadow) => {
+            // if value === string it was probably already transformed
+            if (typeof shadow === 'string')
+                return shadow;
+            checkRequiredTokenProperties(shadow, ['color', 'offsetX', 'offsetY', 'blur', 'spread']);
+            /*css box shadow:  inset? | offset-x | offset-y | blur-radius | spread-radius | color */
+            return `${shadow.inset === true ? 'inset ' : ''}${shadow.offsetX} ${shadow.offsetY} ${shadow.blur} ${shadow.spread} ${toHex(alpha(getTokenValue(Object.assign(Object.assign({}, token), { [valueProp]: shadow }), 'color'), shadow.alpha || 1, token))}`;
+        })
+            .join(', ');
+    },
+};

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

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

package/dist/build/transformers/typographyToCss.js

@@ -0,0 +1,27 @@
+import { isTypography } from '../filters/index.js';
+import { checkRequiredTokenProperties } from './utilities/checkRequiredTokenProperties.js';
+import { parseFontFamily } from './fontFamilyToCss.js';
+import { parseFontWeight } from './fontWeightToNumber.js';
+import { getTokenValue } from './utilities/getTokenValue.js';
+/**
+ * @description converts typograhy token value to css font shorthand
+ * @type value transformer — [StyleDictionary.ValueTransform](https://github.com/amzn/style-dictionary/blob/main/types/Transform.d.ts)
+ * @matcher matches all tokens of $type `typography`
+ * @transformer returns a css font string
+ */
+export const typographyToCss = {
+    name: 'typography/css',
+    type: 'value',
+    transitive: true,
+    filter: isTypography,
+    transform: (token) => {
+        // extract value
+        const value = getTokenValue(token);
+        // validate token properties
+        checkRequiredTokenProperties(value, ['fontWeight', 'fontSize', 'fontFamily']);
+        // format output
+        return `${value.fontStyle || ''} ${parseFontWeight(getTokenValue(token, 'fontWeight'))} ${value.fontSize}${value.lineHeight ? `/${value.lineHeight}` : ''} ${parseFontFamily(getTokenValue(token, 'fontFamily'))}`
+            .trim()
+            .replace(/\s\s+/g, ' ');
+    },
+};

package/dist/build/transformers/utilities/alpha.d.ts

@@ -0,0 +1,9 @@
+import type { TransformedToken } from 'style-dictionary/types';
+/**
+ * alpha
+ * @description takes a colors string like hex or rgba and returns an rgba color with the specified alpha value
+ * @param color color string like a `#334455` or `rgb(255,200,100)`
+ * @param desiredAlpha number
+ * @returns rgba value
+ */
+export declare const alpha: (color: string, desiredAlpha: number, token?: TransformedToken) => string;

package/dist/build/transformers/utilities/alpha.js

@@ -0,0 +1,16 @@
+import { rgba, parseToRgba } from 'color2k';
+/**
+ * alpha
+ * @description takes a colors string like hex or rgba and returns an rgba color with the specified alpha value
+ * @param color color string like a `#334455` or `rgb(255,200,100)`
+ * @param desiredAlpha number
+ * @returns rgba value
+ */
+export const alpha = (color, desiredAlpha, token) => {
+    const [r, g, b, a] = parseToRgba(color);
+    if (a < 1 && desiredAlpha < 1) {
+        // eslint-disable-next-line no-console
+        console.warn(`🚨 You are setting an alpha value of "${desiredAlpha}" for a color with an alpha value (${color}). The previous alpha value will be disregarded as if the color would have been 100% opaque.${token !== undefined ? `\n ↳ Token: "${token.name}" in file: "${token.filePath}"` : ''}`);
+    }
+    return rgba(r, g, b, desiredAlpha);
+};

package/dist/build/transformers/utilities/checkRequiredTokenProperties.d.ts

@@ -0,0 +1,7 @@
+/**
+ * checks if all required properties exist on token
+ * @param object - tokenValue
+ * @param array - property names
+ * @returns void or throws error
+ */
+export declare const checkRequiredTokenProperties: (tokenValue: Record<string, unknown>, requiredProperties: readonly string[]) => void;

package/dist/build/transformers/utilities/checkRequiredTokenProperties.js

@@ -0,0 +1,13 @@
+/**
+ * checks if all required properties exist on token
+ * @param object - tokenValue
+ * @param array - property names
+ * @returns void or throws error
+ */
+export const checkRequiredTokenProperties = (tokenValue, requiredProperties) => {
+    for (const prop of requiredProperties) {
+        if (prop in tokenValue === false) {
+            throw new Error(`Missing property: ${prop} on token with value ${JSON.stringify(tokenValue)}`);
+        }
+    }
+};

package/dist/build/transformers/utilities/getTokenValue.d.ts

@@ -0,0 +1,2 @@
+import type { TransformedToken } from 'style-dictionary/types';
+export declare const getTokenValue: (token: TransformedToken, property?: string) => any;

package/dist/build/transformers/utilities/getTokenValue.js

@@ -0,0 +1,16 @@
+import { invalidTokenValueError, invalidTokenValuePropertyError } from './invalidTokenError.js';
+export const getTokenValue = (token, property) => {
+    var _a;
+    const value = (_a = token.$value) !== null && _a !== void 0 ? _a : token.value;
+    if (value === undefined) {
+        throw new invalidTokenValueError(token);
+    }
+    // for composite token if subproperty is needed
+    if (typeof property === 'string' && value[property] === undefined) {
+        throw new invalidTokenValuePropertyError(token, property);
+    }
+    if (typeof property === 'string') {
+        return value[property];
+    }
+    return value;
+};

package/dist/build/transformers/utilities/hasSpaceInString.d.ts

@@ -0,0 +1 @@
+export declare const hasSpaceInString: (string: string) => boolean;

package/dist/build/transformers/utilities/hasSpaceInString.js

@@ -0,0 +1,6 @@
+export const hasSpaceInString = (string) => {
+    if (typeof string !== 'string') {
+        throw new TypeError(`Invalid input. Input must be a string, ${typeof string} provided`);
+    }
+    return /\s/g.test(string);
+};

package/dist/build/transformers/utilities/hexToRgbaFloat.d.ts

@@ -0,0 +1,2 @@
+import type { RgbaFloat } from './isRgbaFloat.js';
+export declare const hexToRgbaFloat: (hex: string, alpha?: number) => RgbaFloat;

package/dist/build/transformers/utilities/hexToRgbaFloat.js

@@ -0,0 +1,29 @@
+export const hexToRgbaFloat = (hex, alpha) => {
+    // retrieve spots from hex value (hex 3, hex 4, hex 6 or hex 8)
+    let result;
+    if (hex.length > 5) {
+        result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})?$/i.exec(hex);
+    }
+    else {
+        result = /^#?([a-f\d]{1})([a-f\d]{1})([a-f\d]{1})([a-f\d]{1})?$/i.exec(hex);
+    }
+    if (result === null) {
+        throw new Error('Invalid hex value in "hexToRgbaFloat". Please provide a valid hex3, hex4, hex6 or hex8 value.');
+    }
+    // doule characters if hex 3 or hex 4
+    if (hex.length < 6) {
+        result[1] = `${result[1]}${result[1]}`; // double the character
+        result[2] = `${result[2]}${result[2]}`; // double the character
+        result[3] = `${result[3]}${result[3]}`; // double the character
+        if (result[4]) {
+            result[4] = `${result[4]}${result[4]}`; // double the character
+        }
+    }
+    // return parsed rgba float object using alpha value from token, from hex code or defaults to 1
+    return {
+        r: parseInt(result[1], 16) / 255,
+        g: parseInt(result[2], 16) / 255,
+        b: parseInt(result[3], 16) / 255,
+        a: alpha !== undefined ? alpha : result[4] ? parseInt(result[4], 16) / 255 : 1,
+    };
+};

package/dist/build/transformers/utilities/invalidTokenError.d.ts

@@ -0,0 +1,7 @@
+import type { TransformedToken } from 'style-dictionary/types';
+export declare class invalidTokenValueError extends Error {
+    constructor(token: TransformedToken);
+}
+export declare class invalidTokenValuePropertyError extends Error {
+    constructor(token: TransformedToken, property: string);
+}

package/dist/build/transformers/utilities/invalidTokenError.js

@@ -0,0 +1,25 @@
+import { namePathToDotNotation } from '../namePathToDotNotation.js';
+const composeValueErrorMessage = (token) => {
+    var _a, _b;
+    const originalValue = (_a = token.original.$value) !== null && _a !== void 0 ? _a : token.original.value;
+    const value = (_b = token.$value) !== null && _b !== void 0 ? _b : token.value;
+    return `Invalid token "${namePathToDotNotation.transform(token, {}, {})}" in file "${token.filePath}". Transformed value: "${JSON.stringify(value)}". ${originalValue ? `Original value: "${JSON.stringify(originalValue)}" ` : ''}This may be due to referencing a token that does not exists.`;
+};
+const composeValuePropertyErrorMessage = (token, property) => {
+    var _a, _b;
+    const originalValue = (_a = token.original.$value) !== null && _a !== void 0 ? _a : token.original.value;
+    const value = (_b = token.$value) !== null && _b !== void 0 ? _b : token.value;
+    return `Invalid property "${property}" of token "${namePathToDotNotation.transform(token, {}, {})}" in file "${token.filePath}". Transformed property value: "${value[property]}". ${originalValue ? `Original value: "${originalValue[property]}" ` : ''}This may be due to referencing a token that does not exists.`;
+};
+export class invalidTokenValueError extends Error {
+    constructor(token) {
+        super(composeValueErrorMessage(token));
+        Error.captureStackTrace(this, invalidTokenValueError);
+    }
+}
+export class invalidTokenValuePropertyError extends Error {
+    constructor(token, property) {
+        super(composeValuePropertyErrorMessage(token, property));
+        Error.captureStackTrace(this, invalidTokenValuePropertyError);
+    }
+}

package/dist/build/transformers/utilities/isRgbaFloat.d.ts

@@ -0,0 +1,7 @@
+export type RgbaFloat = {
+    r: number;
+    g: number;
+    b: number;
+    a?: number;
+};
+export declare const isRgbaFloat: (value: unknown) => value is RgbaFloat;

package/dist/build/transformers/utilities/isRgbaFloat.js

@@ -0,0 +1,20 @@
+// check if a value is an rgba float object
+export const isRgbaFloat = (value) => {
+    if (value &&
+        typeof value === `object` &&
+        'r' in value &&
+        typeof value.r === `number` &&
+        'g' in value &&
+        typeof value.g === `number` &&
+        'b' in value &&
+        typeof value.b === `number` &&
+        value.r >= 0 &&
+        value.r <= 1 &&
+        value.g >= 0 &&
+        value.g <= 1 &&
+        value.b >= 0 &&
+        value.b <= 1) {
+        return true;
+    }
+    return false;
+};

package/dist/build/transformers/utilities/mix.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Mixes two colors together. Taken from sass's implementation.
+ */
+declare function mix(color1: string, color2: string, weight: number): string;
+export default mix;

package/dist/build/transformers/utilities/mix.js

@@ -0,0 +1,38 @@
+import { rgba, parseToRgba } from 'color2k';
+/**
+ * Mixes two colors together. Taken from sass's implementation.
+ */
+function mix(color1, color2, weight) {
+    const normalize = (n, index) => 
+    // 3rd index is alpha channel which is already normalized
+    index === 3 ? n : n / 255;
+    const [r1, g1, b1, a1] = parseToRgba(color1).map(normalize);
+    const [r2, g2, b2, a2] = parseToRgba(color2).map(normalize);
+    // The formula is copied from the original Sass implementation:
+    // http://sass-lang.com/documentation/Sass/Script/Functions.html#mix-instance_method
+    const normalizedWeight = 2 * weight - 1;
+    const alphaDelta = a1 - a2;
+    const combinedWeight = normalizedWeight * alphaDelta === -1
+        ? normalizedWeight
+        : (normalizedWeight + alphaDelta) / (1 + normalizedWeight * alphaDelta);
+    const weight2 = (combinedWeight + 1) / 2;
+    const weight1 = 1 - weight2;
+    const r = Math.round((r1 * weight1 + r2 * weight2) * 255);
+    const g = Math.round((g1 * weight1 + g2 * weight2) * 255);
+    const b = Math.round((b1 * weight1 + b2 * weight2) * 255);
+    const a = a2 * weight + a1 * (1 - weight);
+    return rgba(r, g, b, a);
+}
+export default mix;
+// Number* weight = ARGR("$weight", Number, 0, 100);
+// double p = weight->value()/100;
+// double w = 2*p - 1;
+// double a = color1->a() - color2->a();
+// double nW = ((w * a == -1) ? w : (w + a)/(1 + w*a))
+// double w1 = (nW + 1)/2.0;
+// double w2 = 1 - w1;
+// return new (ctx.mem) Color(pstate,
+//                            std::round(w1*color1->r() + w2*color2->r()),
+//                            std::round(w1*color1->g() + w2*color2->g()),
+//                            std::round(w1*color1->b() + w2*color2->b()),
+//                            color1->a()*p + color2->a()*(1-p));

package/dist/build/transformers/utilities/rgbaFloatToHex.d.ts

@@ -0,0 +1,6 @@
+export declare const rgbaFloatToHex: ({ r, g, b, a }: {
+    r: number;
+    g: number;
+    b: number;
+    a?: number;
+}, alpha?: boolean) => string;