@terrazzo/parser 0.0.3 → 0.0.4

package/README.md

@@ -0,0 +1,5 @@
+# 💠 @terrazzo/parser
+
+JS API for parsing / validating / transforming DTCG tokens.
+
+[View Documentation](https://terrazzi-docs-beta.pages.dev)

package/build/index.d.ts

@@ -14,6 +14,13 @@ export interface OutputFile {
   contents: string | Buffer;
 }
 
+export interface OutputFileExpanded extends OutputFile {
+  /** The `name` of the plugin that produced this file. */
+  plugin: string;
+  /** How long this output took to make. */
+  time: number;
+}
+
 /** Transformed token with a single value. Note that this may be any type! */
 export interface TokenTransformedSingleValue {
   /** ID unique to this format. If missing, use `token.id`. */
@@ -44,7 +51,9 @@ export interface TransformParams {
   /** ID of an existing format */
   format: string;
   /** Glob of tokens to select (e.g. `"color.*"` to select all tokens starting with `"color."`) */
-  select?: string | string[];
+  id?: string | string[];
+  /** $type(s) to filter for */
+  $type?: string | string[];
   /** Mode name, if selecting a mode (default: `"."`) */
   mode?: string | string[];
 }
@@ -95,7 +104,7 @@ export interface BuildEndHookOptions {
   /** Momoa document */
   ast: DocumentNode;
   /** Final files to be written */
-  outputFiles: OutputFile[];
+  outputFiles: OutputFileExpanded[];
 }
 
 export default function build(

package/build/index.js

@@ -66,14 +66,24 @@ export default async function build(tokens, { ast, logger = new Logger(), config
 
   function getTransforms(params) {
     return (formats[params.format] ?? []).filter((token) => {
+      if (params.$type) {
+        if (typeof params.$type === 'string' && token.$type !== params.$type) {
+          return false;
+        } else if (Array.isArray(params.$type) && !params.$type.some(($type) => token.type === $type)) {
+          return false;
+        }
+      }
       if (
-        params.select &&
-        params.select !== '*' &&
-        !isTokenMatch(token.token.id, Array.isArray(params.select) ? params.select : [params.select])
+        params.id &&
+        params.id !== '*' &&
+        !isTokenMatch(token.token.id, Array.isArray(params.id) ? params.id : [params.id])
       ) {
         return false;
       }
-      return !params.mode || wcmatch(params.mode)(token.mode);
+      if (params.mode && !wcmatch(params.mode)(token.mode)) {
+        return false;
+      }
+      return true;
     });
   }
 
@@ -137,6 +147,7 @@ export default async function build(tokens, { ast, logger = new Logger(), config
   logger.debug({ group: 'parser', task: 'build', message: 'Start build' });
   for (const plugin of config.plugins) {
     if (typeof plugin.build === 'function') {
+      const pluginBuildStart = performance.now();
       await plugin.build({
         tokens,
         ast,
@@ -146,7 +157,12 @@ export default async function build(tokens, { ast, logger = new Logger(), config
           if (result.outputFiles.some((f) => new URL(f.filename, config.outDir).href === resolved.href)) {
             logger.error({ message: `Can’t overwrite file "${filename}"`, label: plugin.name });
           }
-          result.outputFiles.push({ filename, contents });
+          result.outputFiles.push({
+            filename,
+            contents,
+            plugin: plugin.name,
+            time: performance.now() - pluginBuildStart,
+          });
         },
       });
     }
@@ -166,6 +182,7 @@ export default async function build(tokens, { ast, logger = new Logger(), config
       await plugin.buildEnd({
         tokens,
         ast,
+        getTransforms,
         format: (formatID) => createFormatter(formatID),
         outputFiles: structruedClone(result.outputFiles),
       });

package/lint/index.d.ts

@@ -27,6 +27,7 @@ export interface LinterOptions<O = any> {
     severity: LintRuleSeverity;
   };
   ast: DocumentNode;
+  source?: string;
   /** Any options the user has declared for this plugin */
   options?: O;
 }

package/logger.d.ts

@@ -18,12 +18,8 @@ export interface LogEntry {
   continueOnError?: boolean;
   /** (optional) Show a code frame for the erring node */
   node?: AnyNode;
-  /** (optional) To show code frame, provide entire AST to show which line erred (otherwise it’s floating in space) */
-  ast?: DocumentNode;
-  /** (optional) To highlight a specifc part of the code frame, provide line no. (1-based) and col. no. */
-  loc?: SourceLocation['start'];
-  /** (optional) MANUAL codeFrame override (only use for non-JSON errors, like YAML) */
-  code?: string;
+  /** (optional) To show a code frame, provide the original source code */
+  source?: string;
 }
 
 export interface DebugEntry {
@@ -34,7 +30,7 @@ export interface DebugEntry {
   /** Error message to be logged */
   message: string;
   /** (optional) Show code below message */
-  codeFrame?: { code: string; line: number; column: number };
+  codeFrame?: { source: string; line: number; column: number };
   /** (optional) Display performance timing */
   timing?: number;
 }

package/logger.js

@@ -1,5 +1,4 @@
 import { codeFrameColumns } from '@babel/code-frame';
-import { print } from '@humanwhocodes/momoa';
 import color from 'picocolors';
 import wcmatch from 'wildcard-match';
 
@@ -24,10 +23,8 @@ export function formatMessage(entry, severity) {
   if (severity in MESSAGE_COLOR) {
     message = MESSAGE_COLOR[severity](message);
   }
-  if (entry.ast || entry.code) {
-    message = `${message}\n\n${codeFrameColumns(entry.ast ? print(entry.ast, { indent: 2 }) : entry.code, {
-      start: entry.loc ?? { line: 1 },
-    })}`;
+  if (entry.source) {
+    message = `${message}\n\n${codeFrameColumns(entry.source, { start: entry.node?.loc?.start })}`;
   }
   return message;
 }
@@ -89,10 +86,10 @@ export default class Logger {
     let message = formatMessage(entry, 'debug');
 
     const debugPrefix = `${entry.group}:${entry.task}`;
-    if (!wcmatch(this.debugScope)(debugPrefix)) {
+    if (this.debugScope !== '*' && !wcmatch(this.debugScope)(debugPrefix)) {
       return;
     }
-    message = `${DEBUG_GROUP_COLOR[entry.group || 'core'](debugPrefix)} ${color.dim(
+    message = `${(DEBUG_GROUP_COLOR[entry.group] || color.white)(debugPrefix)} ${color.dim(
       timeFormatter.format(new Date()),
     )} ${message}`;
     if (typeof entry.timing === 'number') {
@@ -105,7 +102,8 @@ export default class Logger {
       message = `${message} ${color.dim(`[${timing}]`)}`;
     }
 
-    console.debug(message);
+    // biome-ignore lint/suspicious/noConsoleLog: this is its job
+    console.log(message);
   }
 }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@terrazzo/parser",
   "description": "Parser/validator for the Design Tokens Community Group (DTCG) standard.",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "author": {
     "name": "Drew Powers",
     "email": "drew@pow.rs"

package/parse/index.js

@@ -1,4 +1,4 @@
-import { evaluate, parse as parseJSON } from '@humanwhocodes/momoa';
+import { evaluate, parse as parseJSON, print } from '@humanwhocodes/momoa';
 import { isAlias, parseAlias, splitID } from '@terrazzo/token-tools';
 import lintRunner from '../lint/index.js';
 import Logger from '../logger.js';
@@ -34,6 +34,10 @@ export default async function parse(input, { logger = new Logger(), skipLint = f
   const totalStart = performance.now();
 
   // 1. Build AST
+  let source;
+  if (typeof input === 'string') {
+    source = input;
+  }
   const startParsing = performance.now();
   logger.debug({ group: 'parser', task: 'parse', message: 'Start tokens parsing' });
   let ast;
@@ -44,6 +48,9 @@ export default async function parse(input, { logger = new Logger(), skipLint = f
       mode: 'jsonc',
     }); // everything else: assert it’s JSON-serializable
   }
+  if (!source) {
+    source = print(ast, { indent: 2 });
+  }
   logger.debug({
     group: 'parser',
     task: 'parse',
@@ -86,7 +93,7 @@ export default async function parse(input, { logger = new Logger(), skipLint = f
           if (parent$type && !members.$type) {
             sourceNode.value = injectObjMembers(sourceNode.value, [parent$type]);
           }
-          validate(sourceNode, { ast, logger });
+          validate(sourceNode, { source, logger });
 
           const group = { id: splitID(id).group, tokens: [] };
           if (parent$type) {
@@ -130,7 +137,7 @@ export default async function parse(input, { logger = new Logger(), skipLint = f
 
           tokens[id] = token;
         } else if (members.value) {
-          logger.warn({ message: `Group ${id} has "value". Did you mean "$value"?`, node, ast });
+          logger.warn({ message: `Group ${id} has "value". Did you mean "$value"?`, node, source });
         }
       }
 
@@ -158,7 +165,7 @@ export default async function parse(input, { logger = new Logger(), skipLint = f
       task: 'validate',
       message: 'Start token linting',
     });
-    await lintRunner({ ast, config, logger });
+    await lintRunner({ ast, source, config, logger });
     logger.debug({
       group: 'parser',
       task: 'validate',
@@ -181,7 +188,12 @@ export default async function parse(input, { logger = new Logger(), skipLint = f
     try {
       tokens[id].$value = normalize(tokens[id]);
     } catch (err) {
-      logger.error({ message: err.message, ast, node: tokens[id].sourceNode });
+      let node = tokens[id].sourceNode;
+      const members = getObjMembers(node);
+      if (members.$value) {
+        node = members.$value;
+      }
+      logger.error({ message: err.message, source, node });
     }
     for (const mode in tokens[id].mode) {
       if (mode === '.') {
@@ -190,7 +202,12 @@ export default async function parse(input, { logger = new Logger(), skipLint = f
       try {
         tokens[id].mode[mode].$value = normalize(tokens[id].mode[mode]);
       } catch (err) {
-        logger.error({ message: err.message, ast, node: tokens[id].mode[mode].sourceNode });
+        let node = tokens[id].sourceNode;
+        const members = getObjMembers(node);
+        if (members.$value) {
+          node = members.$value;
+        }
+        logger.error({ message: err.message, source, node: tokens[id].mode[mode].sourceNode });
       }
     }
   }
@@ -207,7 +224,7 @@ export default async function parse(input, { logger = new Logger(), skipLint = f
       continue;
     }
     const token = tokens[id];
-    applyAliases(token, { tokens, ast, node: token.sourceNode, logger });
+    applyAliases(token, { tokens, source, node: token.sourceNode, logger });
     token.mode['.'].$value = token.$value;
     if (token.aliasOf) {
       token.mode['.'].aliasOf = token.aliasOf;
@@ -239,7 +256,7 @@ export default async function parse(input, { logger = new Logger(), skipLint = f
       if (mode === '.') {
         continue; // skip shadow of root value
       }
-      applyAliases(tokens[id].mode[mode], { tokens, ast, node: tokens[id].mode[mode].sourceNode, logger });
+      applyAliases(tokens[id].mode[mode], { tokens, source, node: tokens[id].mode[mode].sourceNode, logger });
     }
   }
   logger.debug({
@@ -277,31 +294,31 @@ export function maybeJSONString(input) {
  * @param {Object} options
  * @param {Record<string, TokenNormalized>} options.tokens
  * @param {Logger} options.logger
- * @param {AnyNode | undefined} options.node
- * @param {DocumentNode | undefined} options.ast
+ * @param {AnyNode} [options.node]
+ * @param {string} [options.string]
  * @param {string[]=[]} options.scanned
  * @param {string}
  */
-export function resolveAlias(alias, { tokens, logger, ast, node, scanned = [] }) {
+export function resolveAlias(alias, { tokens, logger, source, node, scanned = [] }) {
   const { id } = parseAlias(alias);
   if (!tokens[id]) {
-    logger.error({ message: `Alias "${alias}" not found`, ast, node });
+    logger.error({ message: `Alias "${alias}" not found`, source, node });
   }
   if (scanned.includes(id)) {
-    logger.error({ message: `Circular alias detected from "${alias}"`, ast, node });
+    logger.error({ message: `Circular alias detected from "${alias}"`, source, node });
   }
   const token = tokens[id];
   if (!isAlias(token.$value)) {
     return id;
   }
-  return resolveAlias(alias, { tokens, logger, ast, node, scanned: [...scanned, id] });
+  return resolveAlias(alias, { tokens, logger, node, source, scanned: [...scanned, id] });
 }
 
 /** Resolve aliases, update values, and mutate `token` to add `aliasOf` / `partialAliasOf` */
-function applyAliases(token, { tokens, logger, ast, node }) {
+function applyAliases(token, { tokens, logger, source, node }) {
   // handle simple aliases
   if (isAlias(token.$value)) {
-    const aliasOfID = resolveAlias(token.$value, { tokens, logger, node, ast });
+    const aliasOfID = resolveAlias(token.$value, { tokens, logger, node, source });
     const { mode: aliasMode } = parseAlias(token.$value);
     const aliasOf = tokens[aliasOfID];
     token.aliasOf = aliasOfID;
@@ -310,7 +327,6 @@ function applyAliases(token, { tokens, logger, ast, node }) {
       logger.warn({
         message: `Token ${token.id} has $type "${token.$type}" but aliased ${aliasOfID} of $type "${aliasOf.$type}"`,
         node,
-        ast,
       });
       token.$type = aliasOf.$type;
     } else {
@@ -325,7 +341,7 @@ function applyAliases(token, { tokens, logger, ast, node }) {
         if (!token.partialAliasOf) {
           token.partialAliasOf = [];
         }
-        const aliasOfID = resolveAlias(token.$value[i], { tokens, logger, node, ast });
+        const aliasOfID = resolveAlias(token.$value[i], { tokens, logger, node, source });
         const { mode: aliasMode } = parseAlias(token.$value[i]);
         token.partialAliasOf[i] = aliasOfID;
         token.$value[i] = tokens[aliasOfID].mode[aliasMode]?.$value || tokens[aliasOfID].$value;
@@ -338,7 +354,7 @@ function applyAliases(token, { tokens, logger, ast, node }) {
             if (!token.partialAliasOf[i]) {
               token.partialAliasOf[i] = {};
             }
-            const aliasOfID = resolveAlias(token.$value[i][property], { tokens, logger, node, ast });
+            const aliasOfID = resolveAlias(token.$value[i][property], { tokens, logger, node, source });
             const { mode: aliasMode } = parseAlias(token.$value[i][property]);
             token.$value[i][property] = tokens[aliasOfID].mode[aliasMode]?.$value || tokens[aliasOfID].$value;
             token.partialAliasOf[i][property] = aliasOfID;
@@ -358,7 +374,7 @@ function applyAliases(token, { tokens, logger, ast, node }) {
         if (!token.partialAliasOf) {
           token.partialAliasOf = {};
         }
-        const aliasOfID = resolveAlias(token.$value[property], { tokens, logger, node, ast });
+        const aliasOfID = resolveAlias(token.$value[property], { tokens, logger, node, source });
         const { mode: aliasMode } = parseAlias(token.$value[property]);
         token.partialAliasOf[property] = aliasOfID;
         token.$value[property] = tokens[aliasOfID].mode[aliasMode]?.$value || tokens[aliasOfID].$value;
@@ -367,7 +383,7 @@ function applyAliases(token, { tokens, logger, ast, node }) {
       else if (Array.isArray(token.$value[property])) {
         for (let i = 0; i < token.$value[property].length; i++) {
           if (isAlias(token.$value[property][i])) {
-            const aliasOfID = resolveAlias(token.$value[property][i], { tokens, logger, node, ast });
+            const aliasOfID = resolveAlias(token.$value[property][i], { tokens, logger, node, source });
             if (!token.partialAliasOf) {
               token.partialAliasOf = {};
             }

package/parse/validate.d.ts

@@ -7,7 +7,7 @@ declare const STROKE_STYLE_VALUES: Set<string>;
 declare const STROKE_STYLE_LINE_CAP_VALUES: Set<string>;
 
 export interface ValidateOptions {
-  ast: DocumentNode;
+  source: string;
   logger: Logger;
 }
 

package/parse/validate.js

@@ -44,15 +44,6 @@ export const STROKE_STYLE_VALUES = new Set([
 ]);
 export const STROKE_STYLE_LINE_CAP_VALUES = new Set(['round', 'butt', 'square']);
 
-/**
- * Get the location of a JSON node
- * @param {AnyNode} node
- * @return {SourceLocation}
- */
-function getLoc(node) {
-  return { line: node.loc?.start.line ?? 1, column: node.loc?.start.column };
-}
-
 /**
  * Distinct from isAlias() in that this accepts malformed aliases
  * @param {AnyNode} node
@@ -73,21 +64,21 @@ function isMaybeAlias(node) {
  * @param {ValidateOptions} options
  * @return {void}
  */
-function validateMembersAs($value, properties, node, { ast, logger }) {
+function validateMembersAs($value, properties, node, { source, logger }) {
   const members = getObjMembers($value);
   for (const property in properties) {
     const { validator, required } = properties[property];
     if (!members[property]) {
       if (required) {
-        logger.error({ message: `Missing required property "${property}"`, node, ast, loc: getLoc($value) });
+        logger.error({ message: `Missing required property "${property}"`, node: $value, source });
       }
       continue;
     }
     const value = members[property];
     if (isMaybeAlias(value)) {
-      validateAlias(value, node, { ast, logger });
+      validateAlias(value, node, { source, logger });
     } else {
-      validator(value, node, { ast, logger });
+      validator(value, node, { source, logger });
     }
   }
 }
@@ -99,9 +90,9 @@ function validateMembersAs($value, properties, node, { ast, logger }) {
  * @param {ValidateOptions} options
  * @return {void}
  */
-export function validateAlias($value, node, { ast, logger }) {
+export function validateAlias($value, node, { source, logger }) {
   if ($value.type !== 'String' || !isAlias($value.value)) {
-    logger.error({ message: `Invalid alias: ${print($value)}`, node, ast, loc: getLoc($value) });
+    logger.error({ message: `Invalid alias: ${print($value)}`, node: $value, source });
   }
 }
 
@@ -112,9 +103,9 @@ export function validateAlias($value, node, { ast, logger }) {
  * @param {ValidateOptions} options
  * @return {void}
  */
-export function validateBorder($value, node, { ast, logger }) {
+export function validateBorder($value, node, { source, logger }) {
   if ($value.type !== 'Object') {
-    logger.error({ message: `Expected object, received ${$value.type}`, node, ast, loc: getLoc($value) });
+    logger.error({ message: `Expected object, received ${$value.type}`, node: $value, source });
     return;
   }
   validateMembersAs(
@@ -125,7 +116,7 @@ export function validateBorder($value, node, { ast, logger }) {
       width: { validator: validateDimension, required: true },
     },
     node,
-    { ast, logger },
+    { source, logger },
   );
 }
 
@@ -136,11 +127,11 @@ export function validateBorder($value, node, { ast, logger }) {
  * @param {ValidateOptions} options
  * @return {void}
  */
-export function validateColor($value, node, { ast, logger }) {
+export function validateColor($value, node, { source, logger }) {
   if ($value.type !== 'String') {
-    logger.error({ message: `Expected string, received ${$value.type}`, node, ast, loc: getLoc($value) });
+    logger.error({ message: `Expected string, received ${$value.type}`, node: $value, source });
   } else if ($value.value === '') {
-    logger.error({ message: 'Expected color, received empty string', node, ast, loc: getLoc($value) });
+    logger.error({ message: 'Expected color, received empty string', node: $value, source });
   }
 }
 
@@ -151,29 +142,22 @@ export function validateColor($value, node, { ast, logger }) {
  * @param {ValidateOptions} options
  * @return {void}
  */
-export function validateCubicBézier($value, node, { ast, logger }) {
+export function validateCubicBézier($value, node, { source, logger }) {
   if ($value.type !== 'Array') {
-    logger.error({
-      message: `Expected array of strings, received ${print($value)}`,
-      node,
-      ast,
-      loc: getLoc($value),
-    });
+    logger.error({ message: `Expected array of strings, received ${print($value)}`, node: $value, source });
   } else if (
     !$value.elements.every((e) => e.value.type === 'Number' || (e.value.type === 'String' && isAlias(e.value.value)))
   ) {
     logger.error({
       message: 'Expected an array of 4 numbers, received some non-numbers',
-      node,
-      ast,
-      loc: getLoc($value),
+      node: $value,
+      source,
     });
   } else if ($value.elements.length !== 4) {
     logger.error({
       message: `Expected an array of 4 numbers, received ${$value.elements.length}`,
-      node,
-      ast,
-      loc: getLoc($value),
+      node: $value,
+      source,
     });
   }
 }
@@ -185,23 +169,18 @@ export function validateCubicBézier($value, node, { ast, logger }) {
  * @param {ValidateOptions} options
  * @return {void}
  */
-export function validateDimension($value, node, { ast, logger }) {
+export function validateDimension($value, node, { source, logger }) {
   if ($value.type === 'Number' && $value.value === 0) {
     return; // `0` is a valid number
   }
   if ($value.type !== 'String') {
-    logger.error({ message: `Expected string, received ${$value.type}`, node, ast, loc: getLoc($value) });
+    logger.error({ message: `Expected string, received ${$value.type}`, node: $value, source });
   } else if ($value.value === '') {
-    logger.error({ message: 'Expected dimension, received empty string', node, ast, loc: getLoc($value) });
+    logger.error({ message: 'Expected dimension, received empty string', node: $value, source });
   } else if (String(Number($value.value)) === $value.value) {
-    logger.error({ message: 'Missing units', node, ast, loc: getLoc($value) });
+    logger.error({ message: 'Missing units', node: $value, source });
   } else if (!/^[0-9]+/.test($value.value)) {
-    logger.error({
-      message: `Expected dimension with units, received ${print($value)}`,
-      node,
-      ast,
-      loc: getLoc($value),
-    });
+    logger.error({ message: `Expected dimension with units, received ${print($value)}`, node: $value, source });
   }
 }
 
@@ -212,23 +191,18 @@ export function validateDimension($value, node, { ast, logger }) {
  * @param {ValidateOptions} options
  * @return {void}
  */
-export function validateDuration($value, node, { ast, logger }) {
+export function validateDuration($value, node, { source, logger }) {
   if ($value.type === 'Number' && $value.value === 0) {
     return; // `0` is a valid number
   }
   if ($value.type !== 'String') {
-    logger.error({ message: `Expected string, received ${$value.type}`, node, ast, loc: getLoc($value) });
+    logger.error({ message: `Expected string, received ${$value.type}`, node: $value, source });
   } else if ($value.value === '') {
-    logger.error({ message: 'Expected duration, received empty string', node, ast, loc: getLoc($value) });
+    logger.error({ message: 'Expected duration, received empty string', node: $value, source });
   } else if (!/m?s$/.test($value.value)) {
-    logger.error({ message: 'Missing unit "ms" or "s"', node, ast, loc: getLoc($value) });
+    logger.error({ message: 'Missing unit "ms" or "s"', node: $value, source });
   } else if (!/^[0-9]+/.test($value.value)) {
-    logger.error({
-      message: `Expected duration in \`ms\` or \`s\`, received ${print($value)}`,
-      node,
-      ast,
-      loc: getLoc($value),
-    });
+    logger.error({ message: `Expected duration in \`ms\` or \`s\`, received ${print($value)}`, node: $value, source });
   }
 }
 
@@ -239,24 +213,18 @@ export function validateDuration($value, node, { ast, logger }) {
  * @param {ValidateOptions} options
  * @return {void}
  */
-export function validateFontFamily($value, node, { ast, logger }) {
+export function validateFontFamily($value, node, { source, logger }) {
   if ($value.type !== 'String' && $value.type !== 'Array') {
-    logger.error({
-      message: `Expected string or array of strings, received ${$value.type}`,
-      node,
-      ast,
-      loc: getLoc($value),
-    });
+    logger.error({ message: `Expected string or array of strings, received ${$value.type}`, node: $value, source });
   }
   if ($value.type === 'String' && $value.value === '') {
-    logger.error({ message: 'Expected font family name, received empty string', node, ast, loc: getLoc($value) });
+    logger.error({ message: 'Expected font family name, received empty string', node: $value, source });
   }
   if ($value.type === 'Array' && !$value.elements.every((e) => e.value.type === 'String' && e.value.value !== '')) {
     logger.error({
       message: 'Expected an array of strings, received some non-strings or empty strings',
-      node,
-      ast,
-      loc: getLoc($value),
+      node: $value,
+      source,
     });
   }
 }
@@ -268,25 +236,23 @@ export function validateFontFamily($value, node, { ast, logger }) {
  * @param {ValidateOptions} options
  * @return {void}
  */
-export function validateFontWeight($value, node, { ast, logger }) {
+export function validateFontWeight($value, node, { source, logger }) {
   if ($value.type !== 'String' && $value.type !== 'Number') {
     logger.error({
       message: `Expected a font weight name or number 0–1000, received ${$value.type}`,
-      node,
-      ast,
-      loc: getLoc($value),
+      node: $value,
+      source,
     });
   }
   if ($value.type === 'String' && !FONT_WEIGHT_VALUES.has($value.value)) {
     logger.error({
       message: `Unknown font weight ${print($value)}. Expected one of: ${listFormat.format([...FONT_WEIGHT_VALUES])}.`,
-      node,
-      ast,
-      loc: getLoc($value),
+      node: $value,
+      source,
     });
   }
   if ($value.type === 'Number' && ($value.value < 0 || $value.value > 1000)) {
-    logger.error({ message: `Expected number 0–1000, received ${print($value)}`, node, ast, loc: getLoc($value) });
+    logger.error({ message: `Expected number 0–1000, received ${print($value)}`, node: $value, source });
   }
 }
 
@@ -297,14 +263,9 @@ export function validateFontWeight($value, node, { ast, logger }) {
  * @param {ValidateOptions} options
  * @return {void}
  */
-export function validateGradient($value, node, { ast, logger }) {
+export function validateGradient($value, node, { source, logger }) {
   if ($value.type !== 'Array') {
-    logger.error({
-      message: `Expected array of gradient stops, received ${$value.type}`,
-      node,
-      ast,
-      loc: getLoc($value),
-    });
+    logger.error({ message: `Expected array of gradient stops, received ${$value.type}`, node: $value, source });
     return;
   }
   for (let i = 0; i < $value.elements.length; i++) {
@@ -312,9 +273,8 @@ export function validateGradient($value, node, { ast, logger }) {
     if (element.value.type !== 'Object') {
       logger.error({
         message: `Stop #${i + 1}: Expected gradient stop, received ${element.value.type}`,
-        node,
-        ast,
-        loc: getLoc(element),
+        node: element,
+        source,
       });
       break;
     }
@@ -324,8 +284,8 @@ export function validateGradient($value, node, { ast, logger }) {
         color: { validator: validateColor, required: true },
         position: { validator: validateNumber, required: true },
       },
-      node,
-      { ast, logger },
+      element,
+      { source, logger },
     );
   }
 }
@@ -337,9 +297,9 @@ export function validateGradient($value, node, { ast, logger }) {
  * @param {ValidateOptions} options
  * @return {void}
  */
-export function validateNumber($value, node, { ast, logger }) {
+export function validateNumber($value, node, { source, logger }) {
   if ($value.type !== 'Number') {
-    logger.error({ message: `Expected number, received ${$value.type}`, node, ast, loc: getLoc($value) });
+    logger.error({ message: `Expected number, received ${$value.type}`, node: $value, source });
   }
 }
 
@@ -350,9 +310,9 @@ export function validateNumber($value, node, { ast, logger }) {
  * @param {ValidateOptions} options
  * @return {void}
  */
-export function validateShadowLayer($value, node, { ast, logger }) {
+export function validateShadowLayer($value, node, { source, logger }) {
   if ($value.type !== 'Object') {
-    logger.error({ message: `Expected Object, received ${$value.type}`, node, ast, loc: getLoc($value) });
+    logger.error({ message: `Expected Object, received ${$value.type}`, node: $value, source });
     return;
   }
   validateMembersAs(
@@ -365,7 +325,7 @@ export function validateShadowLayer($value, node, { ast, logger }) {
       spread: { validator: validateDimension },
     },
     node,
-    { ast, logger },
+    { source, logger },
   );
 }
 
@@ -376,7 +336,7 @@ export function validateShadowLayer($value, node, { ast, logger }) {
  * @param {ValidateOptions} options
  * @return {void}
  */
-export function validateStrokeStyle($value, node, { ast, logger }) {
+export function validateStrokeStyle($value, node, { source, logger }) {
   // note: strokeStyle’s values are NOT aliasable (unless by string, but that breaks validations)
   if ($value.type === 'String') {
     if (!STROKE_STYLE_VALUES.has($value.value)) {
@@ -384,9 +344,8 @@ export function validateStrokeStyle($value, node, { ast, logger }) {
         message: `Unknown stroke style ${print($value)}. Expected one of: ${listFormat.format([
           ...STROKE_STYLE_VALUES,
         ])}.`,
-        node,
-        ast,
-        loc: getLoc($value),
+        node: $value,
+        source,
       });
     }
   } else if ($value.type === 'Object') {
@@ -395,9 +354,8 @@ export function validateStrokeStyle($value, node, { ast, logger }) {
       if (!strokeMembers[property]) {
         logger.error({
           message: `Missing required property "${property}"`,
-          node,
-          ast,
-          loc: getLoc($value),
+          node: $value,
+          source,
         });
       }
     }
@@ -413,29 +371,31 @@ export function validateStrokeStyle($value, node, { ast, logger }) {
       for (const element of dashArray.elements) {
         if (element.value.type === 'String' && element.value.value !== '') {
           if (isMaybeAlias(element.value)) {
-            validateAlias(element.value, node, { logger, ast });
+            validateAlias(element.value, node, { logger, source });
           } else {
-            validateDimension(element.value, node, { logger, ast });
+            validateDimension(element.value, node, { logger, source });
           }
         } else {
           logger.error({
             message: 'Expected array of strings, recieved some non-strings or empty strings.',
-            node,
-            ast,
-            loc: getLoc(element),
+            node: element,
+            source,
           });
         }
       }
     } else {
       logger.error({
         message: `Expected array of strings, received ${dashArray.type}`,
-        node,
-        ast,
-        loc: getLoc($value),
+        node: $value,
+        source,
       });
     }
   } else {
-    logger.error({ message: `Expected string or object, received ${$value.type}`, node, ast, loc: getLoc($value) });
+    logger.error({
+      message: `Expected string or object, received ${$value.type}`,
+      node: $value,
+      source,
+    });
   }
 }
 
@@ -446,9 +406,9 @@ export function validateStrokeStyle($value, node, { ast, logger }) {
  * @param {ValidateOptions} options
  * @return {void}
  */
-export function validateTransition($value, node, { ast, logger }) {
+export function validateTransition($value, node, { source, logger }) {
   if ($value.type !== 'Object') {
-    logger.error({ message: `Expected object, received ${$value.type}`, node, ast, loc: getLoc($value) });
+    logger.error({ message: `Expected object, received ${$value.type}`, node: $value, source });
     return;
   }
   validateMembersAs(
@@ -459,7 +419,7 @@ export function validateTransition($value, node, { ast, logger }) {
       timingFunction: { validator: validateCubicBézier, required: true },
     },
     node,
-    { ast, logger },
+    { source, logger },
   );
 }
 
@@ -470,13 +430,12 @@ export function validateTransition($value, node, { ast, logger }) {
  * @param {ValidateOptions} options
  * @return {void}
  */
-export default function validate(node, { ast, logger }) {
+export default function validate(node, { source, logger }) {
   if (node.type !== 'Member' && node.type !== 'Object') {
     logger.error({
       message: `Expected Object, received ${JSON.stringify(node.type)}`,
       node,
-      ast,
-      loc: { line: 1 },
+      source,
     });
     return;
   }
@@ -486,63 +445,62 @@ export default function validate(node, { ast, logger }) {
   const $type = rootMembers.$type;
 
   if (!$value) {
-    logger.error({ message: 'Token missing $value', node, ast, loc: getLoc(node) });
+    logger.error({ message: 'Token missing $value', node, source });
     return;
   }
   // If top-level value is a valid alias, this is valid (no need for $type)
   // ⚠️ Important: ALL Object and Array nodes below will need to check for aliases within!
   if (isMaybeAlias($value)) {
-    validateAlias($value, node, { logger, ast });
+    validateAlias($value, node, { logger, source });
     return;
   }
 
   if (!$type) {
-    logger.error({ message: 'Token missing $type', node, ast, loc: getLoc(node) });
+    logger.error({ message: 'Token missing $type', node, source });
     return;
   }
 
   switch ($type.value) {
     case 'color': {
-      validateColor($value, node, { logger, ast });
+      validateColor($value, node, { logger, source });
       break;
     }
     case 'cubicBezier': {
-      validateCubicBézier($value, node, { logger, ast });
+      validateCubicBézier($value, node, { logger, source });
       break;
     }
     case 'dimension': {
-      validateDimension($value, node, { logger, ast });
+      validateDimension($value, node, { logger, source });
       break;
     }
     case 'duration': {
-      validateDuration($value, node, { logger, ast });
+      validateDuration($value, node, { logger, source });
       break;
     }
     case 'fontFamily': {
-      validateFontFamily($value, node, { logger, ast });
+      validateFontFamily($value, node, { logger, source });
       break;
     }
     case 'fontWeight': {
-      validateFontWeight($value, node, { logger, ast });
+      validateFontWeight($value, node, { logger, source });
       break;
     }
     case 'number': {
-      validateNumber($value, node, { logger, ast });
+      validateNumber($value, node, { logger, source });
       break;
     }
     case 'shadow': {
       if ($value.type === 'Object') {
-        validateShadowLayer($value, node, { logger, ast });
+        validateShadowLayer($value, node, { logger, source });
       } else if ($value.type === 'Array') {
         for (const element of $value.elements) {
-          validateShadowLayer(element.value, $value, { logger, ast });
+          validateShadowLayer(element.value, $value, { logger, source });
         }
       } else {
         logger.error({
           message: `Expected shadow object or array of shadow objects, received ${$value.type}`,
-          node,
-          ast,
-          loc: getLoc($value),
+          node: $value,
+          source,
         });
       }
       break;
@@ -551,54 +509,49 @@ export default function validate(node, { ast, logger }) {
     // extensions
     case 'boolean': {
       if ($value.type !== 'Boolean') {
-        logger.error({ message: `Expected boolean, received ${$value.type}`, node, ast, loc: getLoc($value) });
+        logger.error({ message: `Expected boolean, received ${$value.type}`, node: $value, source });
       }
       break;
     }
     case 'link': {
       if ($value.type !== 'String') {
-        logger.error({ message: `Expected string, received ${$value.type}`, node, ast, loc: getLoc($value) });
+        logger.error({ message: `Expected string, received ${$value.type}`, node: $value, source });
       } else if ($value.value === '') {
-        logger.error({ message: 'Expected URL, received empty string', node, ast, loc: getLoc($value) });
+        logger.error({ message: 'Expected URL, received empty string', node: $value, source });
       }
       break;
     }
     case 'string': {
       if ($value.type !== 'String') {
-        logger.error({ message: `Expected string, received ${$value.type}`, node, ast, loc: getLoc($value) });
+        logger.error({ message: `Expected string, received ${$value.type}`, node: $value, source });
       }
       break;
     }
 
     // composite types
     case 'border': {
-      validateBorder($value, node, { ast, logger });
+      validateBorder($value, node, { source, logger });
       break;
     }
     case 'gradient': {
-      validateGradient($value, node, { ast, logger });
+      validateGradient($value, node, { source, logger });
       break;
     }
     case 'strokeStyle': {
-      validateStrokeStyle($value, node, { ast, logger });
+      validateStrokeStyle($value, node, { source, logger });
       break;
     }
     case 'transition': {
-      validateTransition($value, node, { ast, logger });
+      validateTransition($value, node, { source, logger });
       break;
     }
     case 'typography': {
       if ($value.type !== 'Object') {
-        logger.error({ message: `Expected object, received ${$value.type}`, node, ast, loc: getLoc($value) });
+        logger.error({ message: `Expected object, received ${$value.type}`, node: $value, source });
         break;
       }
       if ($value.members.length === 0) {
-        logger.error({
-          message: 'Empty typography token. Must contain at least 1 property.',
-          node,
-          ast,
-          loc: getLoc($value),
-        });
+        logger.error({ message: 'Empty typography token. Must contain at least 1 property.', node: $value, source });
       }
       validateMembersAs(
         $value,
@@ -607,7 +560,7 @@ export default function validate(node, { ast, logger }) {
           fontWeight: { validator: validateFontWeight },
         },
         node,
-        { ast, logger },
+        { source, logger },
       );
       break;
     }

package/parse/yaml.js

@@ -36,8 +36,8 @@ export default function yamlToAST(input, { logger }) {
         logger.error({
           label: 'parse:yaml',
           message: `${error.code} ${error.message}`,
-          code: input,
-          loc: posToLoc(input, error.pos),
+          node: { loc: { start: posToLoc(input, error.pos) } },
+          source: input,
         });
       }
     }