@primer/primitives 10.0.0-rc.fd912e08 → 10.0.0

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,27 @@
+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;
+    // eslint-disable-next-line i18n-text/no-en
+    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;
+    // eslint-disable-next-line i18n-text/no-en
+    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;

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

@@ -0,0 +1,11 @@
+export const rgbaFloatToHex = ({ r, g, b, a }, alpha = true) => {
+    const values = [r, g, b, alpha === true && a && a < 1 ? a : undefined].filter(item => item !== undefined);
+    if (r > 1 || r < 0 || g > 1 || g < 0 || b > 1 || b < 0) {
+        throw new Error('Invalid RgbaFloat value. R, G and B values must be between 0 and 1.');
+    }
+    return `#${values
+        .map(v => Number(parseInt(`${v * 255}`, 10))
+        .toString(16)
+        .padStart(2, '0'))
+        .join('')}`;
+};

package/dist/build/types/Border.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @description a css border string
+ * @format color | style | width
+ */
+type Border = `${string} ${string} ${string}`

package/dist/build/types/BorderTokenValue.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Type definition for w3c border composite token value
+ * @link https://design-tokens.github.io/community-group/format/#border
+ */
+export type StrokeStyleString = 'solid' | 'dashed' | 'dotted' | 'double' | 'groove' | 'ridge' | 'outset' | 'inset'
+export type BorderTokenValue = {
+  color: string
+  width: string
+  style: StrokeStyleString
+}

package/dist/build/types/ColorHex.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @description hex string (6 or 8-digit)
+ */
+type ColorHex = string

package/dist/build/types/PlatformInitializer.d.ts

@@ -0,0 +1,11 @@
+import type {LocalOptions, PlatformConfig} from 'style-dictionary/types'
+
+export type PlatformInitializer = (
+  // the filename including the extension (e.g. `.css`) and any subfolders after the buildPath (e.g. `functional`)
+  outputFile: string,
+  // the prefix is prepended to all tokens
+  prefix: string | undefined,
+  // the build path in which the `outputFile` is placed
+  buildPath: string,
+  options?: LocalOptions,
+) => PlatformConfig

package/dist/build/types/Shadow.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @description a css shadow
+ * @format inset? | offset-x | offset-y | blur-radius? | spread-radius? | color?
+ */
+type Shadow = string

package/dist/build/types/ShadowTokenValue.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Type definition for w3c shadow composite token value
+ * @link https://design-tokens.github.io/community-group/format/#shadow
+ */
+export type ShadowTokenValue = {
+  color: string
+  offsetX: string
+  offsetY: string
+  blur: string
+  spread: string
+  // custom non w3c values
+  inset?: boolean
+  alpha?: number
+}

package/dist/build/types/SizeEm.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @description size in em
+ */
+type SizeEm = `${number}em`

package/dist/build/types/SizePx.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @description size in px
+ */
+type SizePx = `${number}px`

package/dist/build/types/SizeRem.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @description size in rem
+ */
+type SizeRem = `${number}rem`

package/dist/build/types/StyleDictionaryConfigGenerator.d.ts

@@ -0,0 +1,15 @@
+import type {Config, PlatformConfig} from 'style-dictionary/types'
+
+export type ConfigGeneratorOptions = {
+  buildPath: string
+  prefix?: string
+  themed?: boolean
+}
+
+export type StyleDictionaryConfigGenerator = (
+  outputName: string,
+  source: string[],
+  include: string[],
+  options: ConfigGeneratorOptions,
+  platforms?: Record<string, PlatformConfig | undefined>,
+) => Config

package/dist/build/types/TokenBuildInput.d.ts

@@ -0,0 +1,8 @@
+export type TokenBuildInput = {
+  // The output filename WITHOUT the extension
+  filename: string
+  // Array of `filepaths` to token files that should be converted and included in the output. Accepts relative or glob paths.
+  source: string[]
+  // Array of `filepaths` to token fils that should NOT be included in the output, but should be available to reference during compilation e.g. base color scales
+  include: string[]
+}

package/dist/build/types/TypographyTokenValue.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Type definition for w3c typography composite token value
+ * @link https://design-tokens.github.io/community-group/format/#typography
+ */
+export type TypographyTokenValue = {
+  fontFamily: string
+  fontSize: number
+  fontWeight: number
+  lineHeight: number
+  fontStyle?: string
+  letterSpacing?: number
+}

package/dist/build/types/w3cTransformedToken.d.ts

@@ -0,0 +1,8 @@
+import type {TransformedToken} from 'style-dictionary/types'
+
+export type w3cTokenType = 'color' | 'dimension' | 'fontFamily' | 'fontWeight' | 'duration' | 'cubicBezier'
+export type w3cCompositeTokenType = 'shadow' | 'border' | 'gradient' | 'transition' | 'strokeStyle' | 'typography'
+
+export interface w3cTransformedToken extends TransformedToken {
+  $type?: w3cTokenType | w3cCompositeTokenType
+}

package/dist/build/utilities/copyFromDir.d.ts

@@ -0,0 +1,8 @@
+/**
+ * copyFromDir
+ * @description Copies all files from source folder to destination
+ * @param source path
+ * @param destination path
+ * @returns promise of file name array
+ */
+export declare const copyFromDir: (source: string, destination: string) => Promise<string[]>;