@terrazzo/parser 0.10.4 → 2.0.0-alpha.0

package/src/lint/plugin-core/rules/valid-transition.ts

@@ -0,0 +1,61 @@
+import type * as momoa from '@humanwhocodes/momoa';
+import { getObjMember } from '@terrazzo/json-schema-tools';
+import { TRANSITION_REQUIRED_PROPERTIES } from '@terrazzo/token-tools';
+import type { LintRule } from '../../../types.js';
+import { docsLink } from '../lib/docs.js';
+
+export const VALID_TRANSITION = 'core/valid-transition';
+
+const ERROR = 'ERROR';
+const ERROR_INVALID_PROP = 'ERROR_INVALID_PROP';
+
+const rule: LintRule<typeof ERROR | typeof ERROR_INVALID_PROP> = {
+  meta: {
+    messages: {
+      [ERROR]: `Missing required properties: ${new Intl.ListFormat(undefined, { type: 'conjunction' }).format(TRANSITION_REQUIRED_PROPERTIES)}.`,
+      [ERROR_INVALID_PROP]: 'Unknown property: {{ key }}.',
+    },
+    docs: {
+      description: 'Require transition tokens to follow the format.',
+      url: docsLink(VALID_TRANSITION),
+    },
+  },
+  defaultOptions: {},
+  create({ tokens, report }) {
+    for (const t of Object.values(tokens)) {
+      if (t.aliasOf || !t.originalValue || t.$type !== 'transition') {
+        continue;
+      }
+
+      validateTransition(t.originalValue.$value, {
+        node: getObjMember(t.source.node, '$value') as momoa.ObjectNode,
+        filename: t.source.filename,
+      });
+    }
+
+    // Note: we validate sub-properties using other checks like valid-dimension, valid-font-family, etc.
+    // The only thing remaining is to check that all properties exist (since missing properties won’t appear as invalid)
+    function validateTransition(value: unknown, { node, filename }: { node: momoa.ObjectNode; filename?: string }) {
+      if (
+        !value ||
+        typeof value !== 'object' ||
+        !TRANSITION_REQUIRED_PROPERTIES.every((property) => property in value)
+      ) {
+        report({ messageId: ERROR, node, filename });
+      } else {
+        for (const key of Object.keys(value)) {
+          if (!TRANSITION_REQUIRED_PROPERTIES.includes(key as (typeof TRANSITION_REQUIRED_PROPERTIES)[number])) {
+            report({
+              messageId: ERROR_INVALID_PROP,
+              data: { key: JSON.stringify(key) },
+              node: getObjMember(node, key),
+              filename,
+            });
+          }
+        }
+      }
+    }
+  },
+};
+
+export default rule;

package/src/lint/plugin-core/rules/valid-typography.ts

@@ -0,0 +1,67 @@
+import type * as momoa from '@humanwhocodes/momoa';
+import { getObjMember } from '@terrazzo/json-schema-tools';
+import wcmatch from 'wildcard-match';
+import type { LintRule } from '../../../types.js';
+import { docsLink } from '../lib/docs.js';
+
+export const VALID_TYPOGRAPHY = 'core/valid-typography';
+
+const ERROR = 'ERROR';
+const ERROR_MISSING = 'ERROR_MISSING';
+
+export interface RuleRequiredTypographyPropertiesOptions {
+  /** Required typography properties */
+  requiredProperties: string[];
+  /** Token globs to ignore */
+  ignore?: string[];
+}
+
+const rule: LintRule<typeof ERROR | typeof ERROR_MISSING, RuleRequiredTypographyPropertiesOptions> = {
+  meta: {
+    messages: {
+      [ERROR]: `Expected object, received {{ value }}.`,
+      [ERROR_MISSING]: `Missing required property "{{ property }}".`,
+    },
+    docs: {
+      description: 'Require typography tokens to follow the format.',
+      url: docsLink(VALID_TYPOGRAPHY),
+    },
+  },
+  defaultOptions: {
+    requiredProperties: ['fontFamily', 'fontSize', 'fontWeight', 'letterSpacing', 'lineHeight'],
+  },
+  create({ tokens, options, report }) {
+    const isIgnored = options.ignore ? wcmatch(options.ignore) : () => false;
+    for (const t of Object.values(tokens)) {
+      if (t.aliasOf || !t.originalValue || t.$type !== 'typography' || isIgnored(t.id)) {
+        continue;
+      }
+
+      validateTypography(t.originalValue.$value, {
+        node: getObjMember(t.source.node, '$value') as momoa.ObjectNode,
+        filename: t.source.filename,
+      });
+
+      // Note: we validate sub-properties using other checks like valid-dimension, valid-font-family, etc.
+      // The only thing remaining is to check that all properties exist (since missing properties won’t appear as invalid)
+      function validateTypography(value: unknown, { node, filename }: { node: momoa.ObjectNode; filename?: string }) {
+        if (value && typeof value === 'object') {
+          for (const property of options.requiredProperties) {
+            if (!(property in value)) {
+              report({ messageId: ERROR_MISSING, data: { property }, node, filename });
+            }
+          }
+        } else {
+          report({
+            messageId: ERROR,
+            data: { value: JSON.stringify(value) },
+            node,
+            filename,
+          });
+        }
+      }
+    }
+  },
+};
+
+export default rule;

package/src/logger.ts

@@ -1,14 +1,11 @@
-import type { AnyNode } from '@humanwhocodes/momoa';
+import * as momoa from '@humanwhocodes/momoa';
 import pc from 'picocolors';
 import wcmatch from 'wildcard-match';
 import { codeFrameColumns } from './lib/code-frame.js';
 
 export const LOG_ORDER = ['error', 'warn', 'info', 'debug'] as const;
-
 export type LogSeverity = 'error' | 'warn' | 'info' | 'debug';
-
 export type LogLevel = LogSeverity | 'silent';
-
 export type LogGroup = 'config' | 'parser' | 'lint' | 'plugin' | 'server';
 
 export interface LogEntry {
@@ -26,7 +23,7 @@ export interface LogEntry {
    */
   continueOnError?: boolean;
   /** Show a code frame for the erring node */
-  node?: AnyNode;
+  node?: momoa.AnyNode;
   /** To show a code frame, provide the original source code */
   src?: string;
 }
@@ -64,13 +61,17 @@ export function formatMessage(entry: LogEntry, severity: LogSeverity) {
   if (severity in MESSAGE_COLOR) {
     message = MESSAGE_COLOR[severity]!(message);
   }
-  if (entry.src) {
+  if (entry.node) {
     const start = entry.node?.loc?.start ?? { line: 0, column: 0 };
     //  strip "file://" protocol, but not href
     const loc = entry.filename
       ? `${entry.filename?.href.replace(/^file:\/\//, '')}:${start?.line ?? 0}:${start?.column ?? 0}\n\n`
       : '';
-    const codeFrame = codeFrameColumns(entry.src, { start }, { highlightCode: false });
+    const codeFrame = codeFrameColumns(
+      entry.src ?? momoa.print(entry.node, { indent: 2 }),
+      { start },
+      { highlightCode: false },
+    );
     message = `${message}\n\n${loc}${codeFrame}`;
   }
   return message;
@@ -98,77 +99,87 @@ export default class Logger {
   }
 
   /** Log an error message (always; can’t be silenced) */
-  error(entry: LogEntry) {
-    this.errorCount++;
-    const message = formatMessage(entry, 'error');
-    if (entry.continueOnError) {
-      // biome-ignore lint/suspicious/noConsole: this is a logger
-      console.error(message);
-      return;
+  error(...entries: LogEntry[]) {
+    const message: string[] = [];
+    let firstNode: momoa.AnyNode | undefined;
+    for (const entry of entries) {
+      this.errorCount++;
+      message.push(formatMessage(entry, 'error'));
+      if (entry.node) {
+        firstNode = entry.node;
+      }
     }
-    if (entry.node) {
-      throw new TokensJSONError(message);
+    if (entries.every((e) => e.continueOnError)) {
+      // biome-ignore lint/suspicious/noConsole: this is a logger
+      console.error(message.join('\n\n'));
     } else {
-      throw new Error(message);
+      const e = firstNode ? new TokensJSONError(message.join('\n\n')) : new Error(message.join('\n\n'));
+      throw e;
     }
   }
 
   /** Log an info message (if logging level permits) */
-  info(entry: LogEntry) {
-    this.infoCount++;
-    if (this.level === 'silent' || LOG_ORDER.indexOf(this.level) < LOG_ORDER.indexOf('info')) {
-      return;
+  info(...entries: LogEntry[]) {
+    for (const entry of entries) {
+      this.infoCount++;
+      if (this.level === 'silent' || LOG_ORDER.indexOf(this.level) < LOG_ORDER.indexOf('info')) {
+        return;
+      }
+      const message = formatMessage(entry, 'info');
+      // biome-ignore lint/suspicious/noConsole: this is a logger
+      console.log(message);
     }
-    const message = formatMessage(entry, 'info');
-    // biome-ignore lint/suspicious/noConsole: this is a logger
-    console.log(message);
   }
 
   /** Log a warning message (if logging level permits) */
-  warn(entry: LogEntry) {
-    this.warnCount++;
-    if (this.level === 'silent' || LOG_ORDER.indexOf(this.level) < LOG_ORDER.indexOf('warn')) {
-      return;
+  warn(...entries: LogEntry[]) {
+    for (const entry of entries) {
+      this.warnCount++;
+      if (this.level === 'silent' || LOG_ORDER.indexOf(this.level) < LOG_ORDER.indexOf('warn')) {
+        return;
+      }
+      const message = formatMessage(entry, 'warn');
+      // biome-ignore lint/suspicious/noConsole: this is a logger
+      console.warn(message);
     }
-    const message = formatMessage(entry, 'warn');
-    // biome-ignore lint/suspicious/noConsole: this is a logger
-    console.warn(message);
   }
 
   /** Log a diagnostics message (if logging level permits) */
-  debug(entry: DebugEntry) {
-    if (this.level === 'silent' || LOG_ORDER.indexOf(this.level) < LOG_ORDER.indexOf('debug')) {
-      return;
-    }
-    this.debugCount++;
+  debug(...entries: DebugEntry[]) {
+    for (const entry of entries) {
+      if (this.level === 'silent' || LOG_ORDER.indexOf(this.level) < LOG_ORDER.indexOf('debug')) {
+        return;
+      }
+      this.debugCount++;
 
-    let message = formatMessage(entry, 'debug');
+      let message = formatMessage(entry, 'debug');
 
-    const debugPrefix = entry.label ? `${entry.group}:${entry.label}` : entry.group;
-    if (this.debugScope !== '*' && !wcmatch(this.debugScope)(debugPrefix)) {
-      return;
-    }
+      const debugPrefix = entry.label ? `${entry.group}:${entry.label}` : entry.group;
+      if (this.debugScope !== '*' && !wcmatch(this.debugScope)(debugPrefix)) {
+        return;
+      }
 
-    // debug color
-    message
-      .replace(/\[config[^\]]+\]/, (match) => pc.green(match))
-      .replace(/\[parser[^\]]+\]/, (match) => pc.magenta(match))
-      .replace(/\[lint[^\]]+\]/, (match) => pc.yellow(match))
-      .replace(/\[plugin[^\]]+\]/, (match) => pc.cyan(match));
-
-    message = `${pc.dim(timeFormatter.format(performance.now()))} ${message}`;
-    if (typeof entry.timing === 'number') {
-      let timing = '';
-      if (entry.timing < 1_000) {
-        timing = `${Math.round(entry.timing * 100) / 100}ms`;
-      } else if (entry.timing < 60_000) {
-        timing = `${Math.round(entry.timing * 100) / 100_000}s`;
+      // debug color
+      message
+        .replace(/\[config[^\]]+\]/, (match) => pc.green(match))
+        .replace(/\[parser[^\]]+\]/, (match) => pc.magenta(match))
+        .replace(/\[lint[^\]]+\]/, (match) => pc.yellow(match))
+        .replace(/\[plugin[^\]]+\]/, (match) => pc.cyan(match));
+
+      message = `${pc.dim(timeFormatter.format(performance.now()))} ${message}`;
+      if (typeof entry.timing === 'number') {
+        let timing = '';
+        if (entry.timing < 1_000) {
+          timing = `${Math.round(entry.timing * 100) / 100}ms`;
+        } else if (entry.timing < 60_000) {
+          timing = `${Math.round(entry.timing * 100) / 100_000}s`;
+        }
+        message = `${message}${timing ? pc.dim(` [${timing}]`) : ''}`;
       }
-      message = `${message} ${pc.dim(`[${timing}]`)}`;
-    }
 
-    // biome-ignore lint/suspicious/noConsole: this is a logger
-    console.log(message);
+      // biome-ignore lint/suspicious/noConsole: this is a logger
+      console.log(message);
+    }
   }
 
   /** Get stats for current logger instance */

package/src/parse/index.ts

@@ -1,46 +1,11 @@
-import { type DocumentNode, evaluate, type MemberNode, type ObjectNode } from '@humanwhocodes/momoa';
-import { pluralize, splitID, type Token, type TokenNormalized } from '@terrazzo/token-tools';
-import type ytm from 'yaml-to-momoa';
+import { pluralize, type TokenNormalizedSet } from '@terrazzo/token-tools';
 import lintRunner from '../lint/index.js';
 import Logger from '../logger.js';
-import type { ConfigInit, InputSource } from '../types.js';
-import applyAliases from './alias.js';
-import { getObjMembers, parseJSON, replaceObjMembers, toMomoa, traverse } from './json.js';
-import normalize from './normalize.js';
-import validateTokenNode, { computeInheritedProperty, isGroupNode, type Visitors } from './validate.js';
-
-export * from './alias.js';
-export * from './json.js';
-export * from './normalize.js';
-export * from './validate.js';
-export { normalize, validateTokenNode };
-
-export interface ParseOptions {
-  logger?: Logger;
-  config: ConfigInit;
-  /**
-   * Skip lint step
-   * @default false
-   */
-  skipLint?: boolean;
-  /**
-   * Continue on error? (Useful for `tz check`)
-   * @default false
-   */
-  continueOnError?: boolean;
-  /** Provide yamlToMomoa module to parse YAML (by default, this isn’t shipped to cut down on package weight) */
-  yamlToMomoa?: typeof ytm;
-  /**
-   * Transform API
-   * @see https://terrazzo.app/docs/api/js#transform-api
-   */
-  transform?: Visitors;
-  /** (internal cache; do not use) */
-  _sources?: Record<string, InputSource>;
-}
+import type { ConfigInit, InputSource, ParseOptions } from '../types.js';
+import { loadSources } from './load.js';
 
 export interface ParseResult {
-  tokens: Record<string, TokenNormalized>;
+  tokens: TokenNormalizedSet;
   sources: InputSource[];
 }
 
@@ -54,93 +19,31 @@ export default async function parse(
     continueOnError = false,
     yamlToMomoa,
     transform,
-    _sources = {},
   }: ParseOptions = {} as ParseOptions,
 ): Promise<ParseResult> {
-  const input = Array.isArray(_input) ? _input : [_input];
-  let tokensSet: Record<string, TokenNormalized> = {};
-
-  if (!Array.isArray(input)) {
-    logger.error({ group: 'parser', label: 'init', message: 'Input must be an array of input objects.' });
-  }
-  await Promise.all(
-    input.map(async (src, i) => {
-      if (!src || typeof src !== 'object') {
-        logger.error({ group: 'parser', label: 'init', message: `Input (${i}) must be an object.` });
-      }
-      if (!src.src || (typeof src.src !== 'string' && typeof src.src !== 'object')) {
-        logger.error({
-          message: `Input (${i}) missing "src" with a JSON/YAML string, or JSON object.`,
-          group: 'parser',
-          label: 'init',
-        });
-      }
-      if (src.filename) {
-        if (!(src.filename instanceof URL)) {
-          logger.error({
-            message: `Input (${i}) "filename" must be a URL (remote or file URL).`,
-            group: 'parser',
-            label: 'init',
-          });
-        }
-
-        // if already parsed/scanned, skip
-        if (_sources[src.filename.href]) {
-          return;
-        }
-      }
-
-      const result = await parseSingle(src.src, {
-        filename: src.filename!,
-        logger,
-        config,
-        skipLint,
-        continueOnError,
-        yamlToMomoa,
-        transform,
-      });
-      tokensSet = Object.assign(tokensSet, result.tokens);
-      if (src.filename) {
-        _sources[src.filename.href] = {
-          filename: src.filename,
-          src: result.src,
-          document: result.document,
-        };
-      }
-    }),
-  );
+  const inputs = Array.isArray(_input) ? _input : [_input];
 
   const totalStart = performance.now();
-
-  // 5. Resolve aliases and populate groups
-  const aliasesStart = performance.now();
-  let aliasCount = 0;
-  for (const [id, token] of Object.entries(tokensSet)) {
-    applyAliases(token, {
-      tokensSet,
-      filename: _sources[token.source.loc!]?.filename!,
-      src: _sources[token.source.loc!]?.src as string,
-      node: (getObjMembers(token.source.node).$value as any) || token.source.node,
-      logger,
-    });
-    aliasCount++;
-    const { group: parentGroup } = splitID(id);
-    if (parentGroup) {
-      for (const siblingID of Object.keys(tokensSet)) {
-        const { group: siblingGroup } = splitID(siblingID);
-        if (siblingGroup?.startsWith(parentGroup)) {
-          token.group.tokens.push(siblingID);
-        }
-      }
-    }
-  }
+  const initStart = performance.now();
+  const { tokens, sources } = await loadSources(inputs, { logger, config, continueOnError, yamlToMomoa, transform });
   logger.debug({
-    message: `Resolved ${aliasCount} aliases`,
+    message: 'Loaded tokens',
     group: 'parser',
-    label: 'alias',
-    timing: performance.now() - aliasesStart,
+    label: 'core',
+    timing: performance.now() - initStart,
   });
 
+  if (skipLint !== true && config?.plugins?.length) {
+    const lintStart = performance.now();
+    await lintRunner({ tokens, sources, config, logger });
+    logger.debug({
+      message: 'Lint finished',
+      group: 'plugin',
+      label: 'lint',
+      timing: performance.now() - lintStart,
+    });
+  }
+
   logger.debug({
     message: 'Finish all parser tasks',
     group: 'parser',
@@ -159,215 +62,7 @@ export default async function parse(
   }
 
   return {
-    tokens: tokensSet,
-    sources: Object.values(_sources),
-  };
-}
-
-/** Parse a single input */
-async function parseSingle(
-  input: string | Record<string, any>,
-  {
-    filename,
-    logger,
-    config,
-    skipLint,
-    continueOnError = false,
-    transform,
-    yamlToMomoa, // optional dependency, declared here so the parser itself doesn’t have to load a heavy dep in-browser
-  }: {
-    filename: URL;
-    logger: Logger;
-    config: ConfigInit;
-    skipLint: boolean;
-    continueOnError?: boolean;
-    transform: ParseOptions['transform'] | undefined;
-    yamlToMomoa?: typeof ytm;
-  },
-): Promise<{ tokens: Record<string, Token>; document: DocumentNode; src?: string }> {
-  // 1. Build AST
-  const startParsing = performance.now();
-  let { src, document } = toMomoa(input, { filename, logger, continueOnError, yamlToMomoa });
-  logger.debug({
-    group: 'parser',
-    label: 'json',
-    message: 'Finish JSON parsing',
-    timing: performance.now() - startParsing,
-  });
-  const tokensSet: Record<string, TokenNormalized> = {};
-
-  // 1a. if there’s a root() transformer, then re-parse
-  if (transform?.root) {
-    const json = typeof input === 'string' ? JSON.parse(input) : input;
-    const result = transform?.root(json, '.', document);
-    if (result) {
-      const reRunResult = toMomoa(result, { filename, logger, continueOnError /* YAML not needed in transform() */ });
-      src = reRunResult.src;
-      document = reRunResult.document;
-    }
-  }
-
-  // 2. Walk AST to validate tokens
-  let tokenCount = 0;
-  const startValidate = performance.now();
-  // $type and $deprecated can be applied at group level to target all child tokens,
-  // these two objects keep track of inherited prop values as we traverse the token tree
-  const $typeInheritance: Record<string, MemberNode> = {};
-  const $deprecatedInheritance: Record<string, MemberNode> = {};
-  traverse(document, {
-    enter(node, parent, subpath) {
-      // if $type appears at root of tokens.json, collect it
-      if (node.type === 'Document' && node.body.type === 'Object' && node.body.members) {
-        const { members: rootMembers } = node.body;
-        if (isGroupNode(node.body)) {
-          const root$type = rootMembers.find((m) => m.name.type === 'String' && m.name.value === '$type');
-          if (root$type) {
-            $typeInheritance['.'] = root$type;
-          }
-          const root$deprecated = rootMembers.find((m) => m.name.type === 'String' && m.name.value === '$deprecated');
-          if (root$deprecated) {
-            $deprecatedInheritance['.'] = root$deprecated;
-          }
-        }
-      }
-
-      // for transform() visitors, all non-tokens MUST be handled at this point (besides "root", which was handled above)
-      if (
-        node.type === 'Object' && // JSON object
-        subpath.length &&
-        !node.members.some((m) => m.name.type === 'String' && m.name.value === '$value') && // not the token node itself
-        !subpath.includes('$value') && // not a child of a token node, either
-        !subpath.includes('$extensions') // not metadata
-      ) {
-        if (transform?.group) {
-          const newJSON = transform?.group(evaluate(node), subpath.join('.'), node);
-          if (newJSON) {
-            replaceObjMembers(node, parseJSON(newJSON));
-          }
-        }
-      }
-
-      // handle tokens
-      if (node.type === 'Member') {
-        const inheritedDeprecatedNode = computeInheritedProperty(node, '$deprecated', {
-          subpath,
-          inherited: $deprecatedInheritance,
-        });
-        const inheritedTypeNode = computeInheritedProperty(node, '$type', { subpath, inherited: $typeInheritance });
-        if (node.value.type === 'Object') {
-          const $value = node.value.members.find((m) => m.name.type === 'String' && m.name.value === '$value');
-
-          // Call transform using either inherited type or token-level type
-          let typeNode = inheritedTypeNode;
-          if (!typeNode) {
-            const local$type = node.value.members.find((m) => m.name.type === 'String' && m.name.value === '$type');
-            if (local$type) {
-              typeNode = local$type as MemberNode;
-            }
-          }
-
-          if ($value && typeNode?.value.type === 'String' && transform?.[typeNode.value.value]) {
-            const result = transform[typeNode.value.value]?.(evaluate(node.value), subpath.join('.'), node);
-            if (result) {
-              node.value = parseJSON(result).body;
-            }
-          }
-
-          const token = validateTokenNode(node, {
-            filename,
-            src,
-            config,
-            logger,
-            parent,
-            subpath,
-            transform,
-            inheritedDeprecatedNode,
-            inheritedTypeNode,
-          });
-          if (token) {
-            tokensSet[token.id] = token;
-            tokenCount++;
-          }
-        }
-      }
-    },
-  });
-  logger.debug({
-    message: `Validated ${tokenCount} tokens`,
-    group: 'parser',
-    label: 'validate',
-    timing: performance.now() - startValidate,
-  });
-
-  // 3. normalize values
-  const normalizeStart = performance.now();
-  for (const [id, token] of Object.entries(tokensSet)) {
-    try {
-      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({
-        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 {
-        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({
-          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();
-    await lintRunner({ tokens: tokensSet, src, config, logger });
-    logger.debug({
-      message: `Linted ${tokenCount} tokens`,
-      group: 'parser',
-      label: 'lint',
-      timing: performance.now() - lintStart,
-    });
-  } else {
-    logger.debug({ message: 'Linting skipped', group: 'parser', label: 'lint' });
-  }
-
-  return {
-    tokens: tokensSet,
-    document,
-    src,
+    tokens,
+    sources,
   };
 }