@terrazzo/parser/dist/resolver/create-synthetic-resolver.js

Parser/validator for the Design Tokens Community Group (DTCG) standard.

import * as momoa from '@humanwhocodes/momoa';
import { createResolver } from './load.js';
import { normalizeResolver } from './normalize.js';
/**
 * Interop layer upgrading legacy Terrazzo modes to resolvers
 */
export async function createSyntheticResolver(tokens, { config, logger, req, sources }) {
    const contexts = {};
    for (const token of Object.values(tokens)) {
        for (const [mode, value] of Object.entries(token.mode)) {
            if (!(mode in contexts)) {
                contexts[mode] = [{}];
            }
            addToken(contexts[mode][0], { ...token, $value: value.$value }, { logger });
        }
    }
    const src = JSON.stringify({
        name: 'Terrazzo',
        version: '2025.10',
        resolutionOrder: [{ $ref: '#/sets/allTokens' }, { $ref: '#/modifiers/tzMode' }],
        sets: {
            allTokens: { sources: [simpleFlatten(tokens, { logger })] },
        },
        modifiers: {
            tzMode: {
                description: 'Automatically built from $extensions.mode',
                contexts,
                default: '.',
            },
        },
    }, undefined, 2);
    const normalized = await normalizeResolver(momoa.parse(src), {
        filename: new URL('file:///virtual:resolver.json'),
        logger,
        req,
        src,
    });
    return createResolver(normalized, { config, logger, sources, orthogonal: true });
}
/** Add a normalized token back into an arbitrary, hierarchial structure */
function addToken(structure, token, { logger }) {
    let node = structure;
    const parts = token.id.split('.');
    const localID = parts.pop();
    for (const part of parts) {
        if (!(part in node)) {
            node[part] = {};
        }
        node = node[part];
    }
    if (localID in node) {
        logger.error({ group: 'parser', label: 'resolver', message: `${localID} already exists!` });
    }
    node[localID] = { $type: token.$type, $value: token.$value };
}
/** Downconvert normalized tokens back into a simplified, hierarchial shape. This is extremely lossy, and only done to build a resolver. */
function simpleFlatten(tokens, { logger }) {
    const group = {};
    for (const token of Object.values(tokens)) {
        addToken(group, token, { logger });
    }
    return group;
}
//# sourceMappingURL=create-synthetic-resolver.js.map