@terrazzo/parser 0.0.9 → 0.0.11

package/README.md

@@ -1,4 +1,4 @@
-# 💠 @terrazzo/parser
+# ⛋ @terrazzo/parser
 
 JS API for parsing / validating / transforming DTCG tokens.
 

package/config.js

@@ -11,12 +11,16 @@ const TRAILING_SLASH_RE = /\/*$/;
  * @param {Logger} options.logger
  * @param {URL} options.cwd
  */
-export default function defineConfig(rawConfig, { logger = new Logger(), cwd = import.meta.url } = {}) {
+export default function defineConfig(rawConfig, { logger = new Logger(), cwd } = {}) {
   const configStart = performance.now();
 
+  if (!cwd) {
+    logger.error({ label: 'core', message: 'defineConfig() missing `cwd` for JS API' });
+  }
+
   logger.debug({ group: 'parser', task: 'config', message: 'Start config validation' });
 
-  const config = { ...rawConfig };
+  const config = merge({}, rawConfig);
 
   // config.tokens
   if (rawConfig.tokens === undefined) {
@@ -26,7 +30,7 @@ export default function defineConfig(rawConfig, { logger = new Logger(), cwd = i
   } else if (Array.isArray(rawConfig.tokens)) {
     config.tokens = [];
     for (const file of rawConfig.tokens) {
-      if (typeof file === 'string') {
+      if (typeof file === 'string' || file instanceof URL) {
         config.tokens.push(file); // will be normalized in next step
       } else {
         logger.error({
@@ -43,15 +47,20 @@ export default function defineConfig(rawConfig, { logger = new Logger(), cwd = i
   }
   for (let i = 0; i < config.tokens.length; i++) {
     const filepath = config.tokens[i];
+    if (filepath instanceof URL) {
+      continue; // skip if already resolved
+    }
     try {
       config.tokens[i] = new URL(filepath, cwd);
-    } catch {
+    } catch (err) {
       logger.error({ label: 'config.tokens', message: `Invalid URL ${filepath}` });
     }
   }
 
   // config.outDir
-  if (typeof config.outDir === 'undefined') {
+  if (config.outDir instanceof URL) {
+    // noop
+  } else if (typeof config.outDir === 'undefined') {
     config.outDir = new URL('./tokens/', cwd);
   } else if (typeof config.outDir !== 'string') {
     logger.error({ label: 'config.outDir', message: `Expected string, received ${JSON.stringify(config.outDir)}` });
@@ -95,7 +104,6 @@ export default function defineConfig(rawConfig, { logger = new Logger(), cwd = i
       logger.error({ label: 'config.lint', message: 'Must be an object' });
       return config;
     }
-
     if (!config.lint.build) {
       config.lint.build = { enabled: true };
     }
@@ -109,15 +117,15 @@ export default function defineConfig(rawConfig, { logger = new Logger(), cwd = i
     } else {
       config.lint.build.enabled = true;
     }
-
-    if (config.lint.rules !== undefined) {
+    if (config.lint.rules === undefined) {
+      config.lint.rules = {};
+    } else {
       if (config.lint.rules === null || typeof config.lint.rules !== 'object' || Array.isArray(config.lint.rules)) {
         logger.error({
           label: 'config.lint.rules',
           message: `Expected object, received ${JSON.stringify(config.lint.rules)}`,
         });
       }
-
       for (const id in config.lint.rules) {
         if (!Object.hasOwn(config.lint.rules, id)) {
           continue;

package/logger.d.ts

@@ -36,14 +36,6 @@ export interface DebugEntry {
 
 export default class Logger {
   constructor(options?: { level?: LogLevel; debugScope: string });
-}
-
-export class TokensJSONError extends Error {
-  level: LogLevel;
-  debugScope: string;
-  node?: AnyNode;
-
-  constructor(message: string, node: AnyNode);
 
   setLevel(level: LogLevel): void;
 
@@ -58,4 +50,20 @@ export class TokensJSONError extends Error {
 
   /** Log a diagnostics message (if logging level permits) */
   debug(entry: DebugEntry): void;
+
+  /** Get current stats for logger instance */
+  stats(): {
+    errorCount: number;
+    infoCount: number;
+    warnCount: number;
+    debugCount: number;
+  };
+}
+
+export class TokensJSONError extends Error {
+  level: LogLevel;
+  debugScope: string;
+  node?: AnyNode;
+
+  constructor(message: string, node: AnyNode);
 }

package/logger.js

@@ -32,6 +32,10 @@ export function formatMessage(entry, severity) {
 export default class Logger {
   level = 'info';
   debugScope = '*';
+  errorCount = 0;
+  warnCount = 0;
+  infoCount = 0;
+  debugCount = 0;
 
   constructor(options) {
     if (options?.level) {
@@ -48,6 +52,7 @@ export default class Logger {
 
   /** Log an error message (always; can’t be silenced) */
   error(entry) {
+    this.errorCount++;
     const message = formatMessage(entry, 'error');
     if (entry.continueOnError) {
       console.error(message);
@@ -64,6 +69,7 @@ export default class Logger {
 
   /** Log an info message (if logging level permits) */
   info(entry) {
+    this.infoCount++;
     if (this.level === 'silent' || LOG_ORDER.indexOf(this.level) < LOG_ORDER.indexOf('info')) {
       return;
     }
@@ -73,6 +79,7 @@ export default class Logger {
 
   /** Log a warning message (if logging level permits) */
   warn(entry) {
+    this.warnCount++;
     if (this.level === 'silent' || LOG_ORDER.indexOf(this.level) < LOG_ORDER.indexOf('warn')) {
       return;
     }
@@ -81,6 +88,7 @@ export default class Logger {
 
   /** Log a diagnostics message (if logging level permits) */
   debug(entry) {
+    this.debugCount++;
     if (this.level === 'silent' || LOG_ORDER.indexOf(this.level) < LOG_ORDER.indexOf('debug')) {
       return;
     }
@@ -107,6 +115,16 @@ export default class Logger {
     // biome-ignore lint/suspicious/noConsoleLog: this is its job
     console.log(message);
   }
+
+  /** Get stats for current logger instance */
+  stats() {
+    return {
+      errorCount: this.errorCount,
+      warnCount: this.warnCount,
+      infoCount: this.infoCount,
+      debugCount: this.debugCount,
+    };
+  }
 }
 
 export class TokensJSONError extends Error {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@terrazzo/parser",
-  "version": "0.0.9",
+  "version": "0.0.11",
   "description": "Parser/validator for the Design Tokens Community Group (DTCG) standard.",
   "type": "module",
   "author": {
@@ -46,7 +46,7 @@
   },
   "scripts": {
     "lint": "biome check .",
-    "test": "pnpm run \"/^test:.*/\"",
+    "test": "pnpm --filter @terrazzo/parser run \"/^test:.*/\"",
     "test:js": "vitest run",
     "test:ts": "tsc --noEmit"
   }

package/parse/index.d.ts

@@ -10,6 +10,8 @@ export interface ParseOptions {
   /** Skip lint step (default: false) */
   skipLint?: boolean;
   config: ConfigInit;
+  /** Continue on error? (Useful for `tz check`) (default: false) */
+  continueOnError?: boolean;
 }
 
 export interface ParseResult {

package/parse/index.js

@@ -1,5 +1,5 @@
 import { evaluate, parse as parseJSON, print } from '@humanwhocodes/momoa';
-import { isAlias, parseAlias, splitID } from '@terrazzo/token-tools';
+import { isAlias, parseAlias, pluralize, splitID } from '@terrazzo/token-tools';
 import lintRunner from '../lint/index.js';
 import Logger from '../logger.js';
 import normalize from './normalize.js';
@@ -28,7 +28,10 @@ export * from './validate.js';
  * @param {ParseOptions} options
  * @return {Promise<ParseResult>}
  */
-export default async function parse(input, { logger = new Logger(), skipLint = false, config } = {}) {
+export default async function parse(
+  input,
+  { logger = new Logger(), skipLint = false, config, continueOnError = false } = {},
+) {
   const { plugins } = config;
 
   const totalStart = performance.now();
@@ -193,7 +196,7 @@ export default async function parse(input, { logger = new Logger(), skipLint = f
       if (members.$value) {
         node = members.$value;
       }
-      logger.error({ message: err.message, source, node, continueOnError: true });
+      logger.error({ message: err.message, source, node, continueOnError });
     }
     for (const mode in tokens[id].mode) {
       if (mode === '.') {
@@ -207,7 +210,7 @@ export default async function parse(input, { logger = new Logger(), skipLint = f
         if (members.$value) {
           node = members.$value;
         }
-        logger.error({ message: err.message, source, node: tokens[id].mode[mode].sourceNode, continueOnError: true });
+        logger.error({ message: err.message, source, node: tokens[id].mode[mode].sourceNode, continueOnError });
       }
     }
   }
@@ -273,6 +276,15 @@ export default async function parse(input, { logger = new Logger(), skipLint = f
     timing: performance.now() - totalStart,
   });
 
+  if (continueOnError) {
+    const { errorCount } = logger.stats();
+    if (errorCount > 0) {
+      logger.error({
+        message: `Parser encountered ${errorCount} ${pluralize(errorCount, 'error', 'errors')}. Exiting.`,
+      });
+    }
+  }
+
   return {
     tokens,
     ast,
@@ -302,10 +314,10 @@ export function maybeJSONString(input) {
 export function resolveAlias(alias, { tokens, logger, source, node, scanned = [] }) {
   const { id } = parseAlias(alias);
   if (!tokens[id]) {
-    logger.error({ message: `Alias "${alias}" not found`, source, node, continueOnError: true });
+    logger.error({ message: `Alias "${alias}" not found`, source, node });
   }
   if (scanned.includes(id)) {
-    logger.error({ message: `Circular alias detected from "${alias}"`, source, node, continueOnError: true });
+    logger.error({ message: `Circular alias detected from "${alias}"`, source, node });
   }
   const token = tokens[id];
   if (!isAlias(token.$value)) {

package/parse/normalize.js

@@ -49,7 +49,7 @@ export default function normalizeValue(token) {
     }
     case 'dimension': {
       if (token.$value === 0) {
-        return 0;
+        return '0';
       }
       return typeof token.$value === 'number' ? `${token.$value}px` : token.$value;
     }
@@ -84,7 +84,13 @@ export default function normalizeValue(token) {
       return typeof token.$value === 'number' ? token.$value : Number.parseFloat(token.$value);
     }
     case 'shadow': {
-      return Array.isArray(token.$value) ? token.$value : [token.$value];
+      return (Array.isArray(token.$value) ? token.$value : [token.$value]).map((layer) => ({
+        color: normalizeValue({ $type: 'color', $value: layer.color }),
+        offsetX: normalizeValue({ $type: 'dimension', $value: layer.offsetX ?? 0 }),
+        offsetY: normalizeValue({ $type: 'dimension', $value: layer.offsetY ?? 0 }),
+        blur: normalizeValue({ $type: 'dimension', $value: layer.blur ?? 0 }),
+        spread: normalizeValue({ $type: 'dimension', $value: layer.spread ?? 0 }),
+      }));
     }
     case 'strokeStyle': {
       return token.$value;

package/parse/validate.d.ts

@@ -1,4 +1,4 @@
-import type { AnyNode, DocumentNode, MemberNode, ValueNode } from '@humanwhocodes/momoa';
+import type { AnyNode, MemberNode, ValueNode } from '@humanwhocodes/momoa';
 import type Logger from '../logger.js';
 
 declare const FONT_WEIGHT_VALUES: Set<string>;
@@ -17,7 +17,7 @@ export function validateBorder($value: ValueNode, node: AnyNode, options: Valida
 
 export function validateColor($value: ValueNode, node: AnyNode, options: ValidateOptions): void;
 
-export function validateCubicBézier($value: ValueNode, node: AnyNode, options: ValidateOptions): void;
+export function validateCubicBezier($value: ValueNode, node: AnyNode, options: ValidateOptions): void;
 
 export function validateDimension($value: ValueNode, node: AnyNode, options: ValidateOptions): void;
 

package/parse/validate.js

@@ -220,7 +220,7 @@ export function validateColor($value, node, { source, logger }) {
  * @param {ValidateOptions} options
  * @return {void}
  */
-export function validateCubicBézier($value, node, { source, logger }) {
+export function validateCubicBezier($value, node, { source, logger }) {
   if ($value.type !== 'Array') {
     logger.error({ message: `Expected array of strings, received ${print($value)}`, node: $value, source });
   } else if (
@@ -494,7 +494,7 @@ export function validateTransition($value, node, { source, logger }) {
     {
       duration: { validator: validateDuration, required: true },
       delay: { validator: validateDuration, required: false }, // note: spec says delay is required, but Terrazzo makes delay optional
-      timingFunction: { validator: validateCubicBézier, required: true },
+      timingFunction: { validator: validateCubicBezier, required: true },
     },
     node,
     { source, logger },
@@ -544,7 +544,7 @@ export default function validate(node, { source, logger }) {
       break;
     }
     case 'cubicBezier': {
-      validateCubicBézier($value, node, { logger, source });
+      validateCubicBezier($value, node, { logger, source });
       break;
     }
     case 'dimension': {