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

package/dist/build/formats/javascriptEsm.js

@@ -0,0 +1,26 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { format } from 'prettier';
+import { jsonToNestedValue } from './utilities/jsonToNestedValue.js';
+import { prefixTokens } from './utilities/prefixTokens.js';
+import { fileHeader } from 'style-dictionary/utils';
+/**
+ * @description Converts `StyleDictionary.dictionary.tokens` to javascript esm (javascript export statement)
+ * @param arguments [FormatterArguments](https://github.com/amzn/style-dictionary/blob/main/types/Format.d.ts)
+ * @returns formatted `string`
+ */
+export const javascriptEsm = (_a) => __awaiter(void 0, [_a], void 0, function* ({ dictionary, file, platform }) {
+    // add prefix if defined
+    const tokens = prefixTokens(dictionary.tokens, platform);
+    // add file header and convert output
+    const output = `${yield fileHeader({ file })}export default \n${JSON.stringify(jsonToNestedValue(tokens), null, 2)}\n`;
+    // return prettified
+    return format(output, { parser: 'typescript', printWidth: 500 });
+});

package/dist/build/formats/jsonFigma.d.ts

@@ -0,0 +1,7 @@
+import type { FormatFn } from 'style-dictionary/types';
+/**
+ * @description Converts `StyleDictionary.dictionary.tokens` to javascript esm (javascript export statement)
+ * @param arguments [FormatterArguments](https://github.com/amzn/style-dictionary/blob/main/types/Format.d.ts)
+ * @returns formatted `string`
+ */
+export declare const jsonFigma: FormatFn;

package/dist/build/formats/jsonFigma.js

@@ -0,0 +1,121 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { format } from 'prettier';
+import { transformNamePathToFigma } from '../transformers/namePathToFigma.js';
+import { hexToRgbaFloat } from '../transformers/utilities/hexToRgbaFloat.js';
+import { isRgbaFloat } from '../transformers/utilities/isRgbaFloat.js';
+import { getReferences, sortByReference } from 'style-dictionary/utils';
+const isReference = (string) => /^\{([^\\]*)\}$/g.test(string);
+const getReference = (dictionary, refString, platform) => {
+    var _a;
+    if (isReference(refString)) {
+        // retrieve reference token
+        const refToken = getReferences(refString, dictionary.tokens, { unfilteredTokens: dictionary.unfilteredTokens })[0];
+        // return full reference
+        return [(_a = refToken.attributes) === null || _a === void 0 ? void 0 : _a.collection, transformNamePathToFigma(refToken, platform)].filter(Boolean).join('/');
+    }
+};
+const getFigmaType = (type) => {
+    const validTypes = {
+        color: 'COLOR',
+        dimension: 'FLOAT',
+        fontWeight: 'FLOAT',
+        number: 'FLOAT',
+        fontFamily: 'STRING',
+    };
+    if (type in validTypes)
+        return validTypes[type];
+    throw new Error(`Invalid type: ${type}`);
+};
+const shadowToVariables = (name, values, token) => {
+    // floatValue
+    const floatValue = (property) => ({
+        name: `${name}/${property}`,
+        value: parseInt(values[property].replace('px', '')),
+        type: 'FLOAT',
+        scopes: ['EFFECT_FLOAT'],
+        mode,
+        collection,
+        group,
+    });
+    const { attributes } = token;
+    const { mode, collection, group } = attributes || {};
+    return [
+        floatValue('offsetX'),
+        floatValue('offsetY'),
+        floatValue('blur'),
+        floatValue('spread'),
+        {
+            name: `${name}/color`,
+            value: isRgbaFloat(values.color)
+                ? Object.assign(Object.assign({}, values.color), (values.alpha ? { a: values.alpha } : {})) : hexToRgbaFloat(values.color, values.alpha),
+            type: 'COLOR',
+            scopes: ['EFFECT_COLOR'],
+            mode,
+            collection,
+            group,
+        },
+    ];
+};
+/**
+ * @description Converts `StyleDictionary.dictionary.tokens` to javascript esm (javascript export statement)
+ * @param arguments [FormatterArguments](https://github.com/amzn/style-dictionary/blob/main/types/Format.d.ts)
+ * @returns formatted `string`
+ */
+export const jsonFigma = (_a) => __awaiter(void 0, [_a], void 0, function* ({ dictionary, file: _file, platform }) {
+    // array to store tokens in
+    const tokens = [];
+    const sortedTokens = [...dictionary.allTokens].sort(sortByReference(dictionary.tokens, { unfilteredTokens: dictionary.unfilteredTokens }));
+    // loop through tokens sorted by reference
+    for (const token of sortedTokens) {
+        // deconstruct token
+        const { attributes, $value: value, $type, $description: description, original, alpha, mix } = token;
+        const { mode, collection, scopes, group, codeSyntax } = attributes || {};
+        // early escape if no type is present
+        if (!$type)
+            return;
+        // shadows need to be specifically dealt with
+        if ($type === 'shadow') {
+            const shadowValues = !Array.isArray(value) ? [value] : value;
+            // if only one set of shadow values is present
+            if (shadowValues.length === 1) {
+                tokens.push(...shadowToVariables(token.name, shadowValues[0], Object.assign(Object.assign({}, token), (platform.mode ? { mode: platform.mode } : {}))));
+            }
+            else {
+                // if multiple shadow sets values are present we need loop through them and add the index to the name
+                for (const [index, stepValue] of shadowValues.entries()) {
+                    tokens.push(...shadowToVariables(`${token.name}/${index + 1}`, stepValue, Object.assign(Object.assign({}, token), (platform.mode ? { mode: platform.mode } : {}))));
+                }
+            }
+            // other tokens just get added to tokens array
+        }
+        else {
+            tokens.push({
+                name: token.name,
+                value,
+                type: getFigmaType($type),
+                alpha,
+                isMix: mix ? true : undefined,
+                description,
+                refId: [collection, token.name].filter(Boolean).join('/'),
+                reference: getReference(dictionary, original.$value, platform),
+                collection,
+                mode,
+                group,
+                scopes,
+                codeSyntax,
+            });
+        }
+    }
+    // add file header and convert output
+    const output = JSON.stringify(tokens, null, 2);
+    // return prettified
+    return format(output, { parser: 'json', printWidth: 500 });
+});

package/dist/build/formats/jsonNestedPrefixed.d.ts

@@ -0,0 +1,8 @@
+import type { FormatFn } from 'style-dictionary/types';
+/**
+ * @description Takes a style dictionary token dictionary and converts it to a nested json string.
+ * In contrast to the `json/nested` this formatter does add a prefix if provided
+ * @param FormatFnArguments
+ * @returns formatted json `string`
+ */
+export declare const jsonNestedPrefixed: FormatFn;

package/dist/build/formats/jsonNestedPrefixed.js

@@ -0,0 +1,30 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { format } from 'prettier';
+import { prefixTokens } from './utilities/prefixTokens.js';
+import { jsonToNestedValue } from './utilities/jsonToNestedValue.js';
+/**
+ * @description Takes a style dictionary token dictionary and converts it to a nested json string.
+ * In contrast to the `json/nested` this formatter does add a prefix if provided
+ * @param FormatFnArguments
+ * @returns formatted json `string`
+ */
+export const jsonNestedPrefixed = (_a) => __awaiter(void 0, [_a], void 0, function* ({ dictionary, file: _file, options, platform }) {
+    const { outputVerbose } = options;
+    // add prefix if defined
+    let tokens = prefixTokens(dictionary.tokens, platform);
+    if (!outputVerbose) {
+        tokens = jsonToNestedValue(tokens);
+    }
+    // add file header and convert output
+    const output = JSON.stringify(tokens, null, 2);
+    // return prettified
+    return format(output, { parser: 'json', printWidth: 500 });
+});

package/dist/build/formats/jsonOneDimensional.d.ts

@@ -0,0 +1,8 @@
+import type { FormatFn } from 'style-dictionary/types';
+/**
+ * @description Takes a style dictionary token dictionary and converts it to a one dimensional json object.
+ * @param FormatFnArguments
+ * @param options.nameSeparator - separator to use for nested token name
+ * @returns formatted json `string`
+ */
+export declare const jsonOneDimensional: FormatFn;

package/dist/build/formats/jsonOneDimensional.js

@@ -0,0 +1,32 @@
+import { format } from 'prettier';
+import { jsonToFlat } from './utilities/jsonToFlat.js';
+/**
+ * @description Takes a style dictionary token dictionary and converts it to a one dimensional json object.
+ * @param FormatFnArguments
+ * @param options.nameSeparator - separator to use for nested token name
+ * @returns formatted json `string`
+ */
+export const jsonOneDimensional = ({ dictionary, file: _file, options }) => {
+    // option to allow verbose output (object) or just the value
+    const { outputVerbose, propertyConversion } = options;
+    const tokens = jsonToFlat(dictionary.allTokens, outputVerbose);
+    if (propertyConversion === undefined) {
+        //
+        const output = JSON.stringify(tokens, null, 2);
+        // return prettified
+        return format(output, { parser: 'json', printWidth: 500 });
+    }
+    // replace property names
+    const convertedTokens = Object.fromEntries(Object.entries(tokens).map(([name, token]) => {
+        for (const [from, to] of Object.entries(propertyConversion)) {
+            if (from in token) {
+                token[to] = token[from];
+                delete token[from];
+            }
+        }
+        return [name, token];
+    }));
+    const output = JSON.stringify(convertedTokens, null, 2);
+    // return prettified
+    return format(output, { parser: 'json', printWidth: 500 });
+};

package/dist/build/formats/jsonPostCssFallback.d.ts

@@ -0,0 +1,8 @@
+import type { FormatFn } from 'style-dictionary/types';
+/**
+ * @description Takes a style dictionary token dictionary and converts it to a one dimensional json object.
+ * @param FormatFnArguments
+ * @param options.nameSeparator - separator to use for nested token name
+ * @returns formatted json `string`
+ */
+export declare const jsonPostCssFallback: FormatFn;

package/dist/build/formats/jsonPostCssFallback.js

@@ -0,0 +1,14 @@
+import { format } from 'prettier';
+/**
+ * @description Takes a style dictionary token dictionary and converts it to a one dimensional json object.
+ * @param FormatFnArguments
+ * @param options.nameSeparator - separator to use for nested token name
+ * @returns formatted json `string`
+ */
+export const jsonPostCssFallback = ({ dictionary, file: _file }) => {
+    const tokens = Object.fromEntries(dictionary.allTokens.map(token => [`--${token.name}`, token.$value]));
+    // add file header and convert output
+    const output = JSON.stringify(tokens, null, 2);
+    // return prettified
+    return format(output, { parser: 'json', printWidth: 500 });
+};

package/dist/build/formats/typescriptExportDefinition.d.ts

@@ -0,0 +1,7 @@
+import type { FormatFn } from 'style-dictionary/types';
+/**
+ * @description Converts `StyleDictionary.dictionary.tokens` to typescript definition
+ * @param arguments [FormatterArguments](https://github.com/amzn/style-dictionary/blob/main/types/Format.d.ts)
+ * @returns formatted `string`
+ */
+export declare const typescriptExportDefinition: FormatFn;

package/dist/build/formats/typescriptExportDefinition.js

@@ -0,0 +1,170 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { format } from 'prettier';
+import { readFileSync } from 'fs';
+import { resolve as resolvePath } from 'path';
+import { treeWalker } from '../utilities/treeWalker.js';
+import { prefixTokens } from './utilities/prefixTokens.js';
+import { fileHeader } from 'style-dictionary/utils';
+import { getPropName } from './utilities/getPropName.js';
+/**
+ * unquoteTypes
+ * @description extract types from designTokenTypes (string with type definitions from file) and replace quoted types "Color" with unquoted Color
+ * @param output
+ * @param designTokenTypes
+ * @returns string with unquoted types
+ */
+const unquoteTypes = (output, designTokenTypes) => {
+    // join types for replacement
+    const regex = `"(${['number', 'string', 'any', ...designTokenTypes].join('|')})"`;
+    // remove strings
+    return output.replace(new RegExp(regex, 'g'), '$1');
+};
+/**
+ * getTokenType
+ * @description extract content from token files
+ * @param path string
+ */
+const getTokenType = (tokenTypesPath) => {
+    try {
+        const designTokenType = readFileSync(resolvePath(tokenTypesPath), { encoding: 'utf-8' });
+        return designTokenType;
+    }
+    catch (e) {
+        // eslint-disable-next-line no-console
+        throw new Error(`Error trying to load design token type from file "${tokenTypesPath}".`);
+    }
+};
+/**
+ * @description throws an error stating the token name, type and invalid value
+ * @param token w3cTransformedToken
+ */
+const invalidTokenValueError = (token, options) => {
+    throw new Error(`Invalid token: "${token.name}" with type "${token[getPropName('type', options.usesDtcg)]}" can not have a value of "${token[getPropName('value', options.usesDtcg)]}"`);
+};
+/**
+ * convertPropToType
+ * @description return take type attribute and return correct typescript type as string
+ * @param type
+ * @returns
+ */
+const convertPropToType = (tree, options) => {
+    const valueProp = getPropName('value', options.usesDtcg);
+    if (!Object.prototype.hasOwnProperty.call(tree, valueProp)) {
+        throw new Error(`Invalid token: ${tree}`);
+    }
+    switch (tree.$type) {
+        case 'color':
+            if (typeof tree[valueProp] === 'string' && tree[valueProp][0] === '#') {
+                return 'ColorHex';
+            }
+            return invalidTokenValueError(tree, options);
+        case 'dimension':
+            if (typeof tree[valueProp] === 'string' && tree[valueProp].substring(tree[valueProp].length - 3) === 'rem')
+                return 'SizeRem';
+            if (typeof tree[valueProp] === 'string' && tree[valueProp].substring(tree[valueProp].length - 2) === 'em')
+                return 'SizeEm';
+            if (typeof tree[valueProp] === 'string' && tree[valueProp].substring(tree[valueProp].length - 2) === 'px')
+                return 'SizePx';
+            return invalidTokenValueError(tree, options);
+        case 'shadow':
+            return 'Shadow';
+        case 'border':
+            return 'Border';
+        default:
+            if (typeof tree[valueProp] === 'number')
+                return 'number';
+            if (typeof tree[valueProp] === 'string')
+                return 'string';
+            if (typeof tree[valueProp] === 'boolean')
+                return 'boolean';
+            return 'any';
+    }
+};
+/**
+ * a valid token node has a `value` property
+ * @param item object
+ * @returns boolean
+ */
+const validTokenNode = (usesDtcg) => (item) => {
+    return typeof item === 'object' && item !== null && getPropName('value', usesDtcg) in item;
+};
+/**
+ * returns a set with every used token type
+ * @param item object
+ * @param validTypes array, all other types will be removed
+ * @returns set of all used token types
+ */
+const getUsedTokenTypes = (tokens, validTypes, options) => {
+    // using a set to assure every value only exists once
+    const usedTypes = new Set();
+    // adds type to set
+    const callback = (tree) => usedTypes.add(convertPropToType(tree, options));
+    // tree walker adds to usedTypes
+    treeWalker(tokens, callback, validTokenNode(options.usesDtcg));
+    // clean up types
+    for (const type of usedTypes) {
+        if (!validTypes.includes(type)) {
+            usedTypes.delete(type);
+        }
+    }
+    return usedTypes;
+};
+/**
+ * returns the entire token object structure but instead of token values each token just has a typescript type
+ * @param item object
+ * @returns object
+ */
+const getTokenObjectWithTypes = (tokens, options) => {
+    const callback = (tree) => convertPropToType(tree, options);
+    // TODO: FIX typescript issues
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    return treeWalker(tokens, callback, validTokenNode(options.usesDtcg));
+};
+/**
+ * getTypeDefinition
+ * @description returns type definitions as string
+ * @param tokens
+ * @param moduleName
+ * @param tokenTypesPath
+ * @returns string
+ */
+const getTypeDefinition = (tokens, options) => {
+    // extract options
+    const { moduleName = `tokens`, tokenTypesPath = `./src/types/` } = options;
+    const usedTypes = getUsedTokenTypes(tokens, ['Shadow', 'ColorHex', 'Border', 'SizeEm', 'SizeRem', 'SizePx'], options);
+    const tokenObjectWithTypes = getTokenObjectWithTypes(tokens, options);
+    // get token type declaration from file
+    const designTokenTypes = [];
+    for (const type of usedTypes) {
+        // path to type files without trailing slash
+        const typePath = tokenTypesPath.replace(new RegExp(/\/$/, 'g'), '');
+        designTokenTypes.push(getTokenType(`${typePath}/${type}.d.ts`));
+    }
+    // build output
+    const output = `${designTokenTypes.join('\n')} 
+    export type ${moduleName} = ${JSON.stringify(tokenObjectWithTypes, null, 2)}`;
+    // JSON stringify will quote strings, because this is a type we need it unquoted.
+    return unquoteTypes(output, [...usedTypes]);
+};
+/**
+ * @description Converts `StyleDictionary.dictionary.tokens` to typescript definition
+ * @param arguments [FormatterArguments](https://github.com/amzn/style-dictionary/blob/main/types/Format.d.ts)
+ * @returns formatted `string`
+ */
+export const typescriptExportDefinition = (_a) => __awaiter(void 0, [_a], void 0, function* ({ dictionary, file, options = {}, platform, }) {
+    // add prefix if defined
+    const tokens = prefixTokens(dictionary.tokens, platform);
+    // add file header and convert output
+    const output = `${yield fileHeader({ file })}\n${getTypeDefinition(tokens, options)}\n`;
+    // return prettified
+    return format(output, { parser: 'typescript', printWidth: 500 });
+});

package/dist/build/formats/utilities/getPropName.d.ts

@@ -0,0 +1 @@
+export declare const getPropName: (prop: "value" | "type" | "description", usesDtcg?: boolean) => "type" | "value" | "$value" | "$type" | "$description" | "comment";

package/dist/build/formats/utilities/getPropName.js

@@ -0,0 +1,16 @@
+const props = {
+    dtcg: {
+        value: '$value',
+        type: '$type',
+        description: '$description',
+    },
+    legacy: {
+        value: 'value',
+        type: 'type',
+        description: 'comment',
+    },
+};
+export const getPropName = (prop, usesDtcg) => {
+    const type = usesDtcg ? 'dtcg' : 'legacy';
+    return props[type][prop];
+};

package/dist/build/formats/utilities/jsonToFlat.d.ts

@@ -0,0 +1,11 @@
+import type { TransformedToken } from 'style-dictionary/types';
+/**
+ * jsonToFlat
+ * @description creates a one dimensional json structure with either a single value or an token object as the value
+ * @param token StyleDictionary.DesignToken
+ * @param returnObject - boolean
+ * @returns flat json three
+ */
+export declare const jsonToFlat: (tokens: TransformedToken[], returnObject?: boolean) => {
+    [k: string]: any;
+};

package/dist/build/formats/utilities/jsonToFlat.js

@@ -0,0 +1,8 @@
+/**
+ * jsonToFlat
+ * @description creates a one dimensional json structure with either a single value or an token object as the value
+ * @param token StyleDictionary.DesignToken
+ * @param returnObject - boolean
+ * @returns flat json three
+ */
+export const jsonToFlat = (tokens, returnObject = false) => Object.fromEntries(tokens.map(token => [token.name, returnObject ? token : token.$value]));

package/dist/build/formats/utilities/jsonToNestedValue.d.ts

@@ -0,0 +1,8 @@
+import type { DesignToken } from 'style-dictionary/types';
+/**
+ * jsonToNestedValue
+ * @description creates a nested json tree where every final value is the `.value` prop
+ * @param token StyleDictionary.DesignToken
+ * @returns nested json three
+ */
+export declare const jsonToNestedValue: (token: DesignToken | Record<string, unknown>) => any;

package/dist/build/formats/utilities/jsonToNestedValue.js

@@ -0,0 +1,23 @@
+/**
+ * jsonToNestedValue
+ * @description creates a nested json tree where every final value is the `.value` prop
+ * @param token StyleDictionary.DesignToken
+ * @returns nested json three
+ */
+export const jsonToNestedValue = (token) => {
+    // is non-object value
+    if (typeof token !== 'object')
+        return token;
+    // is design token
+    if ('$value' in token)
+        return token.$value;
+    if ('value' in token)
+        return token.value;
+    // is obj
+    const nextObj = {};
+    for (const [prop, value] of Object.entries(token)) {
+        // @ts-expect-error: can't predict type
+        nextObj[prop] = jsonToNestedValue(value);
+    }
+    return nextObj;
+};

package/dist/build/formats/utilities/prefixTokens.d.ts

@@ -0,0 +1,8 @@
+import type { PlatformConfig, TransformedTokens } from 'style-dictionary/types';
+/**
+ * @description extract prefix from platform and add to tokens array if defined
+ * @param tokens StyleDictionary.TransformedTokens
+ * @param platform StyleDictionary.Platform
+ * @return StyleDictionary.TransformedTokens
+ */
+export declare const prefixTokens: (tokens: TransformedTokens, platform?: PlatformConfig) => TransformedTokens;

package/dist/build/formats/utilities/prefixTokens.js

@@ -0,0 +1,13 @@
+/**
+ * @description extract prefix from platform and add to tokens array if defined
+ * @param tokens StyleDictionary.TransformedTokens
+ * @param platform StyleDictionary.Platform
+ * @return StyleDictionary.TransformedTokens
+ */
+export const prefixTokens = (tokens, platform = {}) => {
+    const { prefix } = platform;
+    if (typeof prefix === 'string') {
+        tokens = { [prefix]: tokens };
+    }
+    return tokens;
+};

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

@@ -0,0 +1 @@
+export { w3cJsonParser } from './w3cJsonParser.js';

package/dist/build/parsers/index.js

@@ -0,0 +1 @@
+export { w3cJsonParser } from './w3cJsonParser.js';

package/dist/build/parsers/w3cJsonParser.d.ts

@@ -0,0 +1,6 @@
+import type { Parser } from 'style-dictionary/types';
+/**
+ * @description Parses a valid [json5](https://json5.org) file and replaces `$value` with `value` and `$description` with `comment` to make a w3c standard file compatible with style dictionary
+ * @pattern supported file extensions `.json` or `.json5`
+ */
+export declare const w3cJsonParser: Parser;

package/dist/build/parsers/w3cJsonParser.js

@@ -0,0 +1,25 @@
+import JSON5 from 'json5';
+/**
+ * @description Parses a valid [json5](https://json5.org) file and replaces `$value` with `value` and `$description` with `comment` to make a w3c standard file compatible with style dictionary
+ * @pattern supported file extensions `.json` or `.json5`
+ */
+export const w3cJsonParser = {
+    name: 'w3cJsonParser',
+    pattern: /\.json5?$/,
+    parser: ({ filePath, contents }) => {
+        // replace $value with value so that style dictionary recognizes it
+        try {
+            contents = contents
+                .replace(/["|']?\$value["|']?:/g, '"value":')
+                // convert $description to comment
+                .replace(/["|']?\$?description["|']?:/g, '"comment":')
+                .replace(/["|']?\$?type["|']?:/g, '"$type":')
+                .replace(/["|']?\$?extensions["|']?:/g, '"$extensions":');
+            //
+            return JSON5.parse(contents);
+        }
+        catch (e) {
+            throw new Error(`Invalid json5 file "${filePath}".`);
+        }
+    },
+};

package/dist/build/platforms/css.d.ts

@@ -0,0 +1,2 @@
+import type { PlatformInitializer } from '../types/PlatformInitializer.ts';
+export declare const css: PlatformInitializer;