@terrazzo/parser 0.4.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,
@@ -105,27 +105,20 @@ export default async function parse(
   const totalStart = performance.now();
 
   // 5. Resolve aliases and populate groups
-  for (const [id, token] of Object.entries(tokens)) {
-    if (!Object.hasOwn(tokens, id)) {
-      continue;
-    }
+  const aliasesStart = performance.now();
+  let aliasCount = 0;
+  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['.']!.$value = token.$value;
-    if (token.aliasOf) {
-      token.mode['.']!.aliasOf = token.aliasOf;
-    }
-    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);
@@ -133,35 +126,11 @@ export default async function parse(
       }
     }
   }
-
-  // 6. resolve mode aliases
-  const modesStart = performance.now();
-  logger.debug({
-    message: 'Start mode resolution',
-    group: 'parser',
-    label: 'modes',
-  });
-  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
-      }
-      applyAliases(modeValue, {
-        tokens,
-        node: modeValue.source.node,
-        logger,
-        src: _sources[token.source.loc!]?.src as string,
-      });
-    }
-  }
   logger.debug({
+    message: `Resolved ${aliasCount} aliases`,
     group: 'parser',
-    label: 'modes',
-    message: 'Finish token modes',
-    timing: performance.now() - modesStart,
+    label: 'alias',
+    timing: performance.now() - aliasesStart,
   });
 
   logger.debug({
@@ -175,13 +144,14 @@ export default async function parse(
     const { errorCount } = logger.stats();
     if (errorCount > 0) {
       logger.error({
+        group: 'parser',
         message: `Parser encountered ${errorCount} ${pluralize(errorCount, 'error', 'errors')}. Exiting.`,
       });
     }
   }
 
   return {
-    tokens,
+    tokens: tokensSet,
     sources: Object.values(_sources),
   };
 }
@@ -207,20 +177,19 @@ async function parseSingle(
 ): Promise<{ tokens: Record<string, Token>; document: DocumentNode; src?: string }> {
   // 1. Build AST
   const startParsing = performance.now();
-  logger.debug({ group: 'parser', label: 'parse', message: 'Start JSON parsing' });
   const { src, document } = toMomoa(input, { filename, logger, continueOnError, yamlToMomoa });
   logger.debug({
     group: 'parser',
-    label: 'parse',
+    label: 'json',
     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;
   const startValidate = performance.now();
   const $typeInheritance: Record<string, Token['$type']> = {};
-  logger.debug({ message: 'Start token validation', group: 'parser', label: 'validate' });
   traverse(document, {
     enter(node, parent, subpath) {
       // if $type appears at root of tokens.json, collect it
@@ -236,70 +205,87 @@ 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++;
         }
       }
     },
   });
-  logger.debug({ message: 'Finish token validation', group: 'parser', label: 'validate', timing: startValidate });
-
-  // 3. normalize values
-  const normalizeStart = performance.now();
   logger.debug({
-    message: 'Start token normalization',
+    message: `Validated ${tokenCount} tokens`,
     group: 'parser',
-    label: 'normalize',
+    label: 'validate',
+    timing: performance.now() - startValidate,
   });
-  for (const [id, token] of Object.entries(tokens)) {
+
+  // 3. normalize values
+  const normalizeStart = performance.now();
+  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);
       if (members.$value) {
         node = members.$value as ObjectNode;
       }
-      logger.error({ message: (err as Error).message, filename, src, node, continueOnError });
+      logger.error({
+        group: 'parser',
+        label: 'normalize',
+        message: (err as Error).message,
+        filename,
+        src,
+        node,
+        continueOnError,
+      });
     }
     for (const [mode, modeValue] of Object.entries(token.mode)) {
       if (mode === '.') {
         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);
         if (members.$value) {
           node = members.$value as ObjectNode;
         }
-        logger.error({ message: (err as Error).message, filename, src, node: modeValue.source.node, continueOnError });
+        logger.error({
+          group: 'parser',
+          label: 'normalize',
+          message: (err as Error).message,
+          filename,
+          src,
+          node: modeValue.source.node,
+          continueOnError,
+        });
       }
     }
   }
+  logger.debug({
+    message: `Normalized ${tokenCount} tokens`,
+    group: 'parser',
+    label: 'normalize',
+    timing: performance.now() - normalizeStart,
+  });
 
   // 4. Execute lint runner with loaded plugins
   if (!skipLint && config?.plugins?.length) {
     const lintStart = performance.now();
-    logger.debug({ message: 'Start token linting', group: 'parser', label: 'validate' });
-    await lintRunner({ tokens, src, config, logger });
+    await lintRunner({ tokens: tokensSet, src, config, logger });
     logger.debug({
-      message: 'Finish token linting',
+      message: `Linted ${tokenCount} tokens`,
       group: 'parser',
-      label: 'validate',
+      label: 'lint',
       timing: performance.now() - lintStart,
     });
+  } else {
+    logger.debug({ message: 'Linting skipped', group: 'parser', label: 'lint' });
   }
 
-  logger.debug({
-    message: 'Finish token normalization',
-    group: 'parser',
-    label: 'normalize',
-    timing: performance.now() - normalizeStart,
-  });
-
   return {
-    tokens,
+    tokens: tokensSet,
     document,
     src,
   };

package/src/parse/json.ts

@@ -55,18 +55,15 @@ export function getObjMembers(node: ObjectNode): Record<string | number, ValueNo
 }
 
 /**
- * Inject members to ObjectNode and return a clone
+ * Inject members to ObjectNode
  * @param {ObjectNode} node
  * @param {MemberNode[]} members
- * @return {ObjectNode}
  */
-export function injectObjMembers(node: ObjectNode, members: MemberNode[] = []): ObjectNode {
+export function injectObjMembers(node: ObjectNode, members: MemberNode[] = []) {
   if (node.type !== 'Object') {
-    return node;
+    return;
   }
-  const newNode = structuredClone(node);
-  newNode.members.push(...members);
-  return newNode;
+  node.members.push(...members);
 }
 
 /**
@@ -176,11 +173,12 @@ export function toMomoa(
       try {
         document = yamlToMomoa(input); // if string, but not JSON, attempt YAML
       } catch (err) {
-        logger.error({ message: String(err), filename, src: input, continueOnError });
+        logger.error({ group: 'parser', label: 'json', message: String(err), filename, src: input, continueOnError });
       }
     } else {
       logger.error({
         group: 'parser',
+        label: 'yaml',
         message: `Install \`yaml-to-momoa\` package to parse YAML, and pass in as option, e.g.:
 
     import { parse } from '@terrazzo/parser';

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) {
@@ -110,7 +111,7 @@ export default function normalizeValue<T extends Token>(token: T): T['$value'] {
       }
       const output: GradientValueNormalized = [];
       for (let i = 0; i < token.$value.length; i++) {
-        const stop = { ...(token.$value[i] as GradientStopNormalized) };
+        const stop = structuredClone(token.$value[i] as GradientStopNormalized);
         stop.color = normalizeValue({ $type: 'color', $value: stop.color! });
         if (stop.position === undefined) {
           stop.position = i / (token.$value.length - 1);
@@ -166,22 +167,28 @@ export default function normalizeValue<T extends Token>(token: T): T['$value'] {
         return token.$value;
       }
       const output: TypographyValueNormalized = {};
-      for (const k in token.$value) {
+      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: token.$value[k] as DimensionValue });
+            output[k] = normalizeValue({ $type: 'dimension', $value: $value as DimensionValue });
             break;
           }
           case 'lineHeight': {
             output[k] = normalizeValue({
               $type: typeof token.$value === 'number' ? 'number' : 'dimension',
-              $value: token.$value[k] as any,
+              $value: $value as any,
             });
             break;
           }
-          default:
-            output[k] = token.$value[k];
+          default: {
+            output[k] = $value;
+            break;
+          }
         }
       }
       return output;