@terrazzo/parser 0.5.0 → 0.6.0

package/src/parse/index.ts

@@ -4,7 +4,7 @@ import type ytm from 'yaml-to-momoa';
 import lintRunner from '../lint/index.js';
 import Logger from '../logger.js';
 import type { ConfigInit, InputSource } from '../types.js';
-import { applyAliases } from './alias.js';
+import applyAliases from './alias.js';
 import { getObjMembers, toMomoa, traverse } from './json.js';
 import normalize from './normalize.js';
 import validateTokenNode from './validate.js';
@@ -51,7 +51,7 @@ export default async function parse(
     _sources = {},
   }: ParseOptions = {} as ParseOptions,
 ): Promise<ParseResult> {
-  let tokens: Record<string, TokenNormalized> = {};
+  let tokensSet: Record<string, TokenNormalized> = {};
 
   if (!Array.isArray(input)) {
     logger.error({ group: 'parser', label: 'init', message: 'Input must be an array of input objects.' });
@@ -91,7 +91,7 @@ export default async function parse(
         continueOnError,
         yamlToMomoa,
       });
-      tokens = Object.assign(tokens, result.tokens);
+      tokensSet = Object.assign(tokensSet, result.tokens);
       if (src.filename) {
         _sources[src.filename.href] = {
           filename: src.filename,
@@ -107,35 +107,18 @@ export default async function parse(
   // 5. Resolve aliases and populate groups
   const aliasesStart = performance.now();
   let aliasCount = 0;
-  for (const [id, token] of Object.entries(tokens)) {
-    if (!Object.hasOwn(tokens, id)) {
-      continue;
-    }
+  for (const [id, token] of Object.entries(tokensSet)) {
     applyAliases(token, {
-      tokens,
+      tokensSet,
       filename: _sources[token.source.loc!]?.filename!,
       src: _sources[token.source.loc!]?.src as string,
-      node: token.source.node,
+      node: (getObjMembers(token.source.node).$value as any) || token.source.node,
       logger,
     });
-    token.mode['.']!.$type = token.$type;
-    token.mode['.']!.$value = token.$value;
-    if (token.aliasOf) {
-      token.mode['.']!.aliasOf = token.aliasOf;
-    }
-    if (token.aliasChain) {
-      token.mode['.']!.aliasChain = token.aliasChain;
-    }
-    if (token.aliasedBy) {
-      token.mode['.']!.aliasedBy = token.aliasedBy;
-    }
-    if (token.partialAliasOf) {
-      token.mode['.']!.partialAliasOf = token.partialAliasOf;
-    }
     aliasCount++;
     const { group: parentGroup } = splitID(id);
     if (parentGroup) {
-      for (const siblingID of Object.keys(tokens)) {
+      for (const siblingID of Object.keys(tokensSet)) {
         const { group: siblingGroup } = splitID(siblingID);
         if (siblingGroup?.startsWith(parentGroup)) {
           token.group.tokens.push(siblingID);
@@ -150,34 +133,6 @@ export default async function parse(
     timing: performance.now() - aliasesStart,
   });
 
-  // 7. resolve mode aliases
-  const modesStart = performance.now();
-  let modeAliasCount = 0;
-  for (const [id, token] of Object.entries(tokens)) {
-    if (!Object.hasOwn(tokens, id)) {
-      continue;
-    }
-    for (const [mode, modeValue] of Object.entries(token.mode)) {
-      if (mode === '.') {
-        continue; // skip shadow of root value
-      }
-      modeAliasCount++;
-      applyAliases(modeValue, {
-        tokens,
-        node: modeValue.source.node,
-        logger,
-        src: _sources[token.source.loc!]?.src as string,
-        skipReverseAlias: true,
-      });
-    }
-  }
-  logger.debug({
-    message: `Resolved ${modeAliasCount} mode aliases`,
-    group: 'parser',
-    label: 'alias',
-    timing: performance.now() - modesStart,
-  });
-
   logger.debug({
     message: 'Finish all parser tasks',
     group: 'parser',
@@ -196,7 +151,7 @@ export default async function parse(
   }
 
   return {
-    tokens,
+    tokens: tokensSet,
     sources: Object.values(_sources),
   };
 }
@@ -229,7 +184,7 @@ async function parseSingle(
     message: 'Finish JSON parsing',
     timing: performance.now() - startParsing,
   });
-  const tokens: Record<string, TokenNormalized> = {};
+  const tokensSet: Record<string, TokenNormalized> = {};
 
   // 2. Walk AST to validate tokens
   let tokenCount = 0;
@@ -250,7 +205,7 @@ async function parseSingle(
       if (node.type === 'Member') {
         const token = validateTokenNode(node, { filename, src, config, logger, parent, subpath, $typeInheritance });
         if (token) {
-          tokens[token.id] = token;
+          tokensSet[token.id] = token;
           tokenCount++;
         }
       }
@@ -265,9 +220,9 @@ async function parseSingle(
 
   // 3. normalize values
   const normalizeStart = performance.now();
-  for (const [id, token] of Object.entries(tokens)) {
+  for (const [id, token] of Object.entries(tokensSet)) {
     try {
-      tokens[id]!.$value = normalize(token);
+      tokensSet[id]!.$value = normalize(token);
     } catch (err) {
       let { node } = token.source;
       const members = getObjMembers(node);
@@ -289,7 +244,7 @@ async function parseSingle(
         continue;
       }
       try {
-        tokens[id]!.mode[mode]!.$value = normalize(modeValue);
+        tokensSet[id]!.mode[mode]!.$value = normalize({ $type: token.$type, ...modeValue });
       } catch (err) {
         let { node } = token.source;
         const members = getObjMembers(node);
@@ -318,7 +273,7 @@ async function parseSingle(
   // 4. Execute lint runner with loaded plugins
   if (!skipLint && config?.plugins?.length) {
     const lintStart = performance.now();
-    await lintRunner({ tokens, src, config, logger });
+    await lintRunner({ tokens: tokensSet, src, config, logger });
     logger.debug({
       message: `Linted ${tokenCount} tokens`,
       group: 'parser',
@@ -330,7 +285,7 @@ async function parseSingle(
   }
 
   return {
-    tokens,
+    tokens: tokensSet,
     document,
     src,
   };

package/src/parse/normalize.ts

@@ -1,6 +1,7 @@
 import {
   type CubicBezierValue,
   type DimensionValue,
+  type FontFamilyValue,
   type GradientStopNormalized,
   type GradientValueNormalized,
   type ShadowValueNormalized,
@@ -39,7 +40,7 @@ const NUMBER_WITH_UNIT_RE = /(-?\d*\.?\d+)(.*)/;
 
 /** Fill in defaults, and return predictable shapes for tokens */
 export default function normalizeValue<T extends Token>(token: T): T['$value'] {
-  if (isAlias(token.$value)) {
+  if (typeof token.$value === 'string' && isAlias(token.$value)) {
     return token.$value;
   }
   switch (token.$type) {
@@ -168,6 +169,10 @@ export default function normalizeValue<T extends Token>(token: T): T['$value'] {
       const output: TypographyValueNormalized = {};
       for (const [k, $value] of Object.entries(token.$value)) {
         switch (k) {
+          case 'fontFamily': {
+            output[k] = normalizeValue({ $type: 'fontFamily', $value: $value as FontFamilyValue });
+            break;
+          }
           case 'fontSize':
           case 'letterSpacing': {
             output[k] = normalizeValue({ $type: 'dimension', $value: $value as DimensionValue });

package/src/parse/validate.ts

@@ -254,10 +254,8 @@ export function validateColor($value: ValueNode, node: AnyNode, { filename, src,
 export function validateCubicBezier($value: ValueNode, _node: AnyNode, { filename, src, logger }: ValidateOptions) {
   const baseMessage = { group: 'parser' as const, label: 'validate', filename, node: $value, src };
   if ($value.type !== 'Array') {
-    logger.error({ ...baseMessage, message: `Expected array of strings, received ${print($value)}` });
-  } else if (
-    !$value.elements.every((e) => e.value.type === 'Number' || (e.value.type === 'String' && isAlias(e.value.value)))
-  ) {
+    logger.error({ ...baseMessage, message: `Expected array of numbers, received ${print($value)}` });
+  } else if (!$value.elements.every((e) => e.value.type === 'Number')) {
     logger.error({ ...baseMessage, message: 'Expected an array of 4 numbers, received some non-numbers' });
   } else if ($value.elements.length !== 4) {
     logger.error({ ...baseMessage, message: `Expected an array of 4 numbers, received ${$value.elements.length}` });
@@ -750,6 +748,11 @@ export interface ValidateTokenNodeOptions {
   $typeInheritance?: Record<string, Token['$type']>;
 }
 
+/**
+ * Validate does a little more than validate; it also converts to TokenNormalized
+ * and sets up the basic data structure. But aliases are unresolved, and we need
+ * a 2nd normalization pass afterward.
+ */
 export default function validateTokenNode(
   node: MemberNode,
   { config, filename, logger, parent, src, subpath, $typeInheritance }: ValidateTokenNodeOptions,
@@ -861,28 +864,18 @@ export default function validateTokenNode(
 
   // handle modes
   // note that circular refs are avoided here, such as not duplicating `modes`
-  const modeValues = extensions?.mode
-    ? getObjMembers(
-        // @ts-ignore
-        extensions.mode,
-      )
-    : {};
+  const modeValues = extensions?.mode ? getObjMembers(extensions.mode as any) : {};
   for (const mode of ['.', ...Object.keys(modeValues)]) {
+    const modeValue = mode === '.' ? token.$value : (evaluate((modeValues as any)[mode]) as any);
     token.mode[mode] = {
-      id: token.id,
-      // @ts-ignore
-      $type: token.$type,
-      // @ts-ignore
-      $value: mode === '.' ? token.$value : evaluate(modeValues[mode]),
+      $value: modeValue,
+      originalValue: modeValue,
       source: {
         loc: filename ? filename.href : undefined,
         // @ts-ignore
-        node: mode === '.' ? structuredClone(token.source.node) : modeValues[mode],
+        node: modeValues[mode],
       },
     };
-    if (token.$description) {
-      token.mode[mode]!.$description = token.$description;
-    }
   }
 
   // logger.debug({