@terrazzo/parser 0.10.3 → 2.0.0-alpha.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@terrazzo/parser",
-  "version": "0.10.3",
+  "version": "2.0.0-alpha.0",
   "description": "Parser/validator for the Design Tokens Community Group (DTCG) standard.",
   "license": "MIT",
   "type": "module",
@@ -34,18 +34,19 @@
     "directory": "./packages/parser/"
   },
   "dependencies": {
-    "@humanwhocodes/momoa": "^3.3.8",
+    "@humanwhocodes/momoa": "^3.3.9",
     "@types/babel__code-frame": "^7.0.6",
-    "@types/culori": "^4.0.0",
+    "@types/culori": "^4.0.1",
     "culori": "^4.0.2",
     "merge-anything": "^5.1.7",
     "picocolors": "^1.1.1",
     "scule": "^1.3.0",
     "wildcard-match": "^5.1.4",
-    "@terrazzo/token-tools": "^0.10.3"
+    "@terrazzo/token-tools": "^2.0.0-alpha.0",
+    "@terrazzo/json-schema-tools": "^0.0.1"
   },
   "devDependencies": {
-    "yaml-to-momoa": "^0.0.3"
+    "yaml-to-momoa": "0.0.6"
   },
   "scripts": {
     "build": "rolldown -c && attw --profile esm-only --pack .",

package/src/build/index.ts

@@ -1,11 +1,11 @@
-import type { DocumentNode } from '@humanwhocodes/momoa';
+import type * as momoa from '@humanwhocodes/momoa';
 import type { TokenNormalized } from '@terrazzo/token-tools';
 import wcmatch from 'wildcard-match';
 import Logger, { type LogEntry } from '../logger.js';
 import type { BuildRunnerResult, ConfigInit, TokenTransformed, TransformParams } from '../types.js';
 
 export interface BuildRunnerOptions {
-  sources: { filename?: URL; src: string; document: DocumentNode }[];
+  sources: { filename?: URL; src: string; document: momoa.DocumentNode }[];
   config: ConfigInit;
   logger?: Logger;
 }
@@ -101,17 +101,8 @@ export default async function build(
           }
           const token = tokens[id]!;
 
-          // allow `undefined` values, but remove them here
           const cleanValue: TokenTransformed['value'] =
             typeof params.value === 'string' ? params.value : { ...(params.value as Record<string, string>) };
-          if (typeof cleanValue === 'object') {
-            for (const k of Object.keys(cleanValue)) {
-              if (cleanValue[k] === undefined) {
-                delete cleanValue[k];
-              }
-            }
-          }
-
           validateTransformParams({
             logger,
             params: { ...(params as any), value: cleanValue },
@@ -155,32 +146,34 @@ export default async function build(
 
   // build()
   const startBuild = performance.now();
-  for (const plugin of config.plugins) {
-    if (typeof plugin.build === 'function') {
-      const pluginBuildStart = performance.now();
-      await plugin.build({
-        tokens,
-        sources,
-        getTransforms,
-        outputFile(filename, contents) {
-          const resolved = new URL(filename, config.outDir);
-          if (result.outputFiles.some((f) => new URL(f.filename, config.outDir).href === resolved.href)) {
-            logger.error({
-              group: 'plugin',
-              message: `Can’t overwrite file "${filename}"`,
-              label: plugin.name,
+  await Promise.all(
+    config.plugins.map(async (plugin) => {
+      if (typeof plugin.build === 'function') {
+        const pluginBuildStart = performance.now();
+        await plugin.build({
+          tokens,
+          sources,
+          getTransforms,
+          outputFile(filename, contents) {
+            const resolved = new URL(filename, config.outDir);
+            if (result.outputFiles.some((f) => new URL(f.filename, config.outDir).href === resolved.href)) {
+              logger.error({
+                group: 'plugin',
+                message: `Can’t overwrite file "${filename}"`,
+                label: plugin.name,
+              });
+            }
+            result.outputFiles.push({
+              filename,
+              contents,
+              plugin: plugin.name,
+              time: performance.now() - pluginBuildStart,
             });
-          }
-          result.outputFiles.push({
-            filename,
-            contents,
-            plugin: plugin.name,
-            time: performance.now() - pluginBuildStart,
-          });
-        },
-      });
-    }
-  }
+          },
+        });
+      }
+    }),
+  );
   logger.debug({
     group: 'parser',
     label: 'build',
@@ -190,11 +183,9 @@ export default async function build(
 
   // buildEnd()
   const startBuildEnd = performance.now();
-  for (const plugin of config.plugins) {
-    if (typeof plugin.buildEnd === 'function') {
-      await plugin.buildEnd({ outputFiles: structuredClone(result.outputFiles) });
-    }
-  }
+  await Promise.all(
+    config.plugins.map(async (plugin) => plugin.buildEnd?.({ outputFiles: structuredClone(result.outputFiles) })),
+  );
   logger.debug({
     group: 'parser',
     label: 'build',

package/src/config.ts

@@ -1,5 +1,5 @@
 import { merge } from 'merge-anything';
-import coreLintPlugin from './lint/plugin-core/index.js';
+import coreLintPlugin, { RECOMMENDED_CONFIG } from './lint/plugin-core/index.js';
 import Logger from './logger.js';
 import type { Config, ConfigInit, ConfigOptions, LintRuleSeverity } from './types.js';
 
@@ -56,12 +56,12 @@ function normalizeTokens({
 }) {
   if (rawConfig.tokens === undefined) {
     config.tokens = [
-      // @ts-ignore we’ll normalize in next step
+      // @ts-expect-error we’ll normalize in next step
       './tokens.json',
     ];
   } else if (typeof rawConfig.tokens === 'string') {
     config.tokens = [
-      // @ts-ignore we’ll normalize in next step
+      // @ts-expect-error we’ll normalize in next step
       rawConfig.tokens,
     ];
   } else if (Array.isArray(rawConfig.tokens)) {
@@ -69,7 +69,7 @@ function normalizeTokens({
     for (const file of rawConfig.tokens) {
       if (typeof file === 'string' || (file as URL) instanceof URL) {
         config.tokens.push(
-          // @ts-ignore we’ll normalize in next step
+          // @ts-expect-error we’ll normalize in next step
           file,
         );
       } else {
@@ -177,7 +177,7 @@ function normalizeLint({ config, logger }: { config: ConfigInit; logger: Logger
     }
 
     if (config.lint.rules === undefined) {
-      config.lint.rules = {};
+      config.lint.rules = { ...RECOMMENDED_CONFIG };
     } else {
       if (config.lint.rules === null || typeof config.lint.rules !== 'object' || Array.isArray(config.lint.rules)) {
         logger.error({
@@ -268,11 +268,18 @@ function normalizeLint({ config, logger }: { config: ConfigInit; logger: Logger
           });
         }
       }
+
+      // Apply recommended config in places user hasn’t explicitly opted-out
+      for (const [id, severity] of Object.entries(RECOMMENDED_CONFIG)) {
+        if (!(id in config.lint.rules)) {
+          config.lint.rules[id] = severity;
+        }
+      }
     }
   } else {
     config.lint = {
       build: { enabled: true },
-      rules: {},
+      rules: { ...RECOMMENDED_CONFIG },
     };
   }
 }

package/src/lib/code-frame.ts

@@ -62,9 +62,9 @@ export interface Options {
  */
 function getMarkerLines(loc: NodeLocation, source: string[], opts: Options = {} as Options) {
   const startLoc = {
-    // @ts-ignore this is fine
+    // @ts-expect-error this is fine
     column: 0,
-    // @ts-ignore this is fine
+    // @ts-expect-error this is fine
     line: -1,
     ...loc.start,
   } as Location;
@@ -132,6 +132,9 @@ function getMarkerLines(loc: NodeLocation, source: string[], opts: Options = {}
 const NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
 
 export function codeFrameColumns(rawLines: string, loc: NodeLocation, opts: Options = {} as Options) {
+  if (typeof rawLines !== 'string') {
+    throw new Error(`Expected string, got ${rawLines}`);
+  }
   const lines = rawLines.split(NEWLINE);
   const { start, end, markerLines } = getMarkerLines(loc, lines, opts);
   const hasColumns = loc.start && typeof loc.start.column === 'number';

package/src/lib/momoa.ts

@@ -0,0 +1,10 @@
+import * as momoa from '@humanwhocodes/momoa';
+
+/** Momoa’s default parser, with preferred settings. */
+export function toMomoa(srcRaw: any): momoa.DocumentNode {
+  return momoa.parse(typeof srcRaw === 'string' ? srcRaw : JSON.stringify(srcRaw, undefined, 2), {
+    mode: 'jsonc',
+    ranges: true,
+    tokens: true,
+  });
+}

package/src/lint/index.ts

@@ -1,15 +1,15 @@
-import { pluralize, type TokenNormalized } from '@terrazzo/token-tools';
+import { pluralize, type TokenNormalizedSet } from '@terrazzo/token-tools';
 import { merge } from 'merge-anything';
 import type { LogEntry, default as Logger } from '../logger.js';
-import type { ConfigInit } from '../types.js';
+import type { ConfigInit, InputSource } from '../types.js';
 
-const listFormat = new Intl.ListFormat('en-us');
+export { RECOMMENDED_CONFIG } from './plugin-core/index.js';
 
 export interface LintRunnerOptions {
-  tokens: Record<string, TokenNormalized>;
+  tokens: TokenNormalizedSet;
   filename?: URL;
   config: ConfigInit;
-  src: string;
+  sources: InputSource[];
   logger: Logger;
 }
 
@@ -17,30 +17,41 @@ export default async function lintRunner({
   tokens,
   filename,
   config = {} as ConfigInit,
-  src,
+  sources,
   logger,
 }: LintRunnerOptions): Promise<void> {
   const { plugins = [], lint } = config;
+  const sourceByFilename: Record<string, InputSource> = {};
+  for (const source of sources) {
+    sourceByFilename[source.filename!.href] = source;
+  }
   const unusedLintRules = Object.keys(lint?.rules ?? {});
 
+  const errors: LogEntry[] = [];
+  const warnings: LogEntry[] = [];
   for (const plugin of plugins) {
     if (typeof plugin.lint === 'function') {
       const s = performance.now();
 
       const linter = plugin.lint();
-      const errors: LogEntry[] = [];
-      const warnings: LogEntry[] = [];
 
       await Promise.all(
         Object.entries(linter).map(async ([id, rule]) => {
           if (!(id in lint.rules) || lint.rules[id] === null) {
             return;
           }
+
+          // tick off used rule
+          const unusedLintRuleI = unusedLintRules.indexOf(id);
+          if (unusedLintRuleI !== -1) {
+            unusedLintRules.splice(unusedLintRuleI, 1);
+          }
+
           const [severity, options] = lint.rules[id]!;
+
           if (severity === 'off') {
             return;
           }
-
           // note: this usually isn’t a Promise, but it _might_ be!
           await rule.create({
             id,
@@ -86,50 +97,43 @@ export default async function lintRunner({
                 message,
                 filename,
                 node: descriptor.node,
-                src: descriptor.source?.src,
+                src: sourceByFilename[descriptor.filename!]?.src,
               });
             },
             tokens,
             filename,
-            src,
+            sources,
             options: merge(
               rule.meta?.defaultOptions ?? [],
               rule.defaultOptions ?? [], // Note: is this the correct order to merge in?
               options,
             ),
           });
-          // tick off used rule
-          const unusedLintRuleI = unusedLintRules.indexOf(id);
-          if (unusedLintRuleI !== -1) {
-            unusedLintRules.splice(unusedLintRuleI, 1);
-          }
         }),
       );
 
-      for (const error of errors) {
-        logger.error({ ...error, continueOnError: true }); // print out all errors before exiting here
-      }
-      for (const warning of warnings) {
-        logger.warn(warning);
-      }
-
-      logger.debug({ group: 'lint', label: plugin.name, message: 'Finished', timing: performance.now() - s });
-
-      if (errors.length) {
-        const counts = [pluralize(errors.length, 'error', 'errors')];
-        if (warnings.length) {
-          counts.push(pluralize(warnings.length, 'warning', 'warnings'));
-        }
-        logger.error({
-          group: 'lint',
-          message: `Lint failed with ${listFormat.format(counts)}`,
-          label: plugin.name,
-          continueOnError: false,
-        });
-      }
+      logger.debug({
+        group: 'lint',
+        label: plugin.name,
+        message: 'Finished',
+        timing: performance.now() - s,
+      });
     }
   }
 
+  const errCount = errors.length ? `${errors.length} ${pluralize(errors.length, 'error', 'errors')}` : '';
+  const warnCount = warnings.length ? `${warnings.length} ${pluralize(warnings.length, 'warning', 'warnings')}` : '';
+  if (errors.length > 0) {
+    logger.error(...errors, {
+      group: 'lint',
+      label: 'lint',
+      message: [errCount, warnCount].filter(Boolean).join(', '),
+    });
+  }
+  if (warnings.length > 0) {
+    logger.warn(...warnings, { group: 'lint', label: 'lint', message: warnCount });
+  }
+
   // warn user if they have unused lint rules (they might have meant to configure something!)
   for (const unusedRule of unusedLintRules) {
     logger.warn({ group: 'lint', label: 'lint', message: `Unknown lint rule "${unusedRule}"` });

package/src/lint/plugin-core/index.ts

@@ -1,6 +1,5 @@
-// Terrazzo internal plugin that powers lint rules. Always enabled (but all
-// rules are opt-in).
-import type { Plugin } from '../../types.js';
+// Terrazzo internal plugin that powers lint rules. Always enabled.
+import type { LintRuleLonghand, Plugin } from '../../types.js';
 
 export * from './rules/a11y-min-contrast.js';
 export * from './rules/a11y-min-font-size.js';
@@ -9,6 +8,7 @@ export * from './rules/consistent-naming.js';
 export * from './rules/descriptions.js';
 export * from './rules/duplicate-values.js';
 export * from './rules/max-gamut.js';
+export * from './rules/no-type-on-alias.js';
 export * from './rules/required-children.js';
 export * from './rules/required-modes.js';
 export * from './rules/required-typography-properties.js';
@@ -20,28 +20,85 @@ import consistentNaming, { CONSISTENT_NAMING } from './rules/consistent-naming.j
 import descriptions, { DESCRIPTIONS } from './rules/descriptions.js';
 import duplicateValues, { DUPLICATE_VALUES } from './rules/duplicate-values.js';
 import maxGamut, { MAX_GAMUT } from './rules/max-gamut.js';
-import requiredChidlren, { REQUIRED_CHILDREN } from './rules/required-children.js';
+import noTypeOnAlias, { NO_TYPE_ON_ALIAS } from './rules/no-type-on-alias.js';
+import requiredChildren, { REQUIRED_CHILDREN } from './rules/required-children.js';
 import requiredModes, { REQUIRED_MODES } from './rules/required-modes.js';
 import requiredTypographyProperties, {
   REQUIRED_TYPOGRAPHY_PROPERTIES,
 } from './rules/required-typography-properties.js';
+import validBoolean, { VALID_BOOLEAN } from './rules/valid-boolean.js';
+import validBorder, { VALID_BORDER } from './rules/valid-border.js';
+import validColor, { VALID_COLOR } from './rules/valid-color.js';
+import validCubicBezier, { VALID_CUBIC_BEZIER } from './rules/valid-cubic-bezier.js';
+import validDimension, { VALID_DIMENSION } from './rules/valid-dimension.js';
+import validDuration, { VALID_DURATION } from './rules/valid-duration.js';
+import validFontFamily, { VALID_FONT_FAMILY } from './rules/valid-font-family.js';
+import validFontWeight, { VALID_FONT_WEIGHT } from './rules/valid-font-weight.js';
+import validGradient, { VALID_GRADIENT } from './rules/valid-gradient.js';
+import validLink, { VALID_LINK } from './rules/valid-link.js';
+import validNumber, { VALID_NUMBER } from './rules/valid-number.js';
+import validShadow, { VALID_SHADOW } from './rules/valid-shadow.js';
+import validString, { VALID_STRING } from './rules/valid-string.js';
+import validStrokeStyle, { VALID_STROKE_STYLE } from './rules/valid-stroke-style.js';
+import validTransition, { VALID_TRANSITION } from './rules/valid-transition.js';
+import validTypography, { VALID_TYPOGRAPHY } from './rules/valid-typography.js';
+
+const ALL_RULES = {
+  [VALID_COLOR]: validColor,
+  [VALID_DIMENSION]: validDimension,
+  [VALID_FONT_FAMILY]: validFontFamily,
+  [VALID_FONT_WEIGHT]: validFontWeight,
+  [VALID_DURATION]: validDuration,
+  [VALID_CUBIC_BEZIER]: validCubicBezier,
+  [VALID_NUMBER]: validNumber,
+  [VALID_LINK]: validLink,
+  [VALID_BOOLEAN]: validBoolean,
+  [VALID_STRING]: validString,
+  [VALID_STROKE_STYLE]: validStrokeStyle,
+  [VALID_BORDER]: validBorder,
+  [VALID_TRANSITION]: validTransition,
+  [VALID_SHADOW]: validShadow,
+  [VALID_GRADIENT]: validGradient,
+  [VALID_TYPOGRAPHY]: validTypography,
+  [COLORSPACE]: colorspace,
+  [CONSISTENT_NAMING]: consistentNaming,
+  [DESCRIPTIONS]: descriptions,
+  [DUPLICATE_VALUES]: duplicateValues,
+  [MAX_GAMUT]: maxGamut,
+  [NO_TYPE_ON_ALIAS]: noTypeOnAlias,
+  [REQUIRED_CHILDREN]: requiredChildren,
+  [REQUIRED_MODES]: requiredModes,
+  [REQUIRED_TYPOGRAPHY_PROPERTIES]: requiredTypographyProperties,
+  [A11Y_MIN_CONTRAST]: a11yMinContrast,
+  [A11Y_MIN_FONT_SIZE]: a11yMinFontSize,
+};
 
 export default function coreLintPlugin(): Plugin {
   return {
     name: '@terrazzo/plugin-lint-core',
     lint() {
-      return {
-        [COLORSPACE]: colorspace,
-        [CONSISTENT_NAMING]: consistentNaming,
-        [DESCRIPTIONS]: descriptions,
-        [DUPLICATE_VALUES]: duplicateValues,
-        [MAX_GAMUT]: maxGamut,
-        [REQUIRED_CHILDREN]: requiredChidlren,
-        [REQUIRED_MODES]: requiredModes,
-        [REQUIRED_TYPOGRAPHY_PROPERTIES]: requiredTypographyProperties,
-        [A11Y_MIN_CONTRAST]: a11yMinContrast,
-        [A11Y_MIN_FONT_SIZE]: a11yMinFontSize,
-      };
+      return ALL_RULES;
     },
   };
 }
+
+export const RECOMMENDED_CONFIG: Record<string, LintRuleLonghand> = {
+  [VALID_COLOR]: ['error', {}],
+  [VALID_DIMENSION]: ['error', {}],
+  [VALID_FONT_FAMILY]: ['error', {}],
+  [VALID_FONT_WEIGHT]: ['error', {}],
+  [VALID_DURATION]: ['error', {}],
+  [VALID_CUBIC_BEZIER]: ['error', {}],
+  [VALID_NUMBER]: ['error', {}],
+  [VALID_LINK]: ['error', {}],
+  [VALID_BOOLEAN]: ['error', {}],
+  [VALID_STRING]: ['error', {}],
+  [VALID_STROKE_STYLE]: ['error', {}],
+  [VALID_BORDER]: ['error', {}],
+  [VALID_TRANSITION]: ['error', {}],
+  [VALID_SHADOW]: ['error', {}],
+  [VALID_GRADIENT]: ['error', {}],
+  [VALID_TYPOGRAPHY]: ['error', {}],
+  [CONSISTENT_NAMING]: ['warn', { format: 'kebab-case' }],
+  [NO_TYPE_ON_ALIAS]: ['warn', {}],
+};

package/src/lint/plugin-core/rules/colorspace.ts

@@ -58,6 +58,7 @@ const rule: LintRule<
               messageId: ERROR_COLOR,
               data: { id: t.id, colorSpace: options.colorSpace },
               node: t.source.node,
+              filename: t.source.filename,
             });
           }
           break;
@@ -68,6 +69,7 @@ const rule: LintRule<
               messageId: ERROR_BORDER,
               data: { id: t.id, colorSpace: options.colorSpace },
               node: t.source.node,
+              filename: t.source.filename,
             });
           }
           break;
@@ -79,6 +81,7 @@ const rule: LintRule<
                 messageId: ERROR_GRADIENT,
                 data: { id: t.id, colorSpace: options.colorSpace },
                 node: t.source.node,
+                filename: t.source.filename,
               });
             }
           }
@@ -91,6 +94,7 @@ const rule: LintRule<
                 messageId: ERROR_SHADOW,
                 data: { id: t.id, colorSpace: options.colorSpace },
                 node: t.source.node,
+                filename: t.source.filename,
               });
             }
           }

package/src/lint/plugin-core/rules/duplicate-values.ts

@@ -57,6 +57,7 @@ const rule: LintRule<typeof ERROR_DUPLICATE_VALUE, RuleDuplicateValueOptions> =
             messageId: ERROR_DUPLICATE_VALUE,
             data: { id: t.id },
             node: t.source.node,
+            filename: t.source.filename,
           });
         }
 
@@ -70,6 +71,7 @@ const rule: LintRule<typeof ERROR_DUPLICATE_VALUE, RuleDuplicateValueOptions> =
               messageId: ERROR_DUPLICATE_VALUE,
               data: { id: t.id },
               node: t.source.node,
+              filename: t.source.filename,
             });
             break;
           }

package/src/lint/plugin-core/rules/max-gamut.ts

@@ -90,20 +90,35 @@ const rule: LintRule<
       switch (t.$type) {
         case 'color': {
           if (!isWithinGamut(t.$value, options.gamut)) {
-            report({ messageId: ERROR_COLOR, data: { id: t.id, gamut: options.gamut }, node: t.source.node });
+            report({
+              messageId: ERROR_COLOR,
+              data: { id: t.id, gamut: options.gamut },
+              node: t.source.node,
+              filename: t.source.filename,
+            });
           }
           break;
         }
         case 'border': {
           if (!t.partialAliasOf?.color && !isWithinGamut(t.$value.color, options.gamut)) {
-            report({ messageId: ERROR_BORDER, data: { id: t.id, gamut: options.gamut }, node: t.source.node });
+            report({
+              messageId: ERROR_BORDER,
+              data: { id: t.id, gamut: options.gamut },
+              node: t.source.node,
+              filename: t.source.filename,
+            });
           }
           break;
         }
         case 'gradient': {
           for (let stopI = 0; stopI < t.$value.length; stopI++) {
             if (!t.partialAliasOf?.[stopI]?.color && !isWithinGamut(t.$value[stopI]!.color, options.gamut)) {
-              report({ messageId: ERROR_GRADIENT, data: { id: t.id, gamut: options.gamut }, node: t.source.node });
+              report({
+                messageId: ERROR_GRADIENT,
+                data: { id: t.id, gamut: options.gamut },
+                node: t.source.node,
+                filename: t.source.filename,
+              });
             }
           }
           break;
@@ -111,7 +126,12 @@ const rule: LintRule<
         case 'shadow': {
           for (let shadowI = 0; shadowI < t.$value.length; shadowI++) {
             if (!t.partialAliasOf?.[shadowI]?.color && !isWithinGamut(t.$value[shadowI]!.color, options.gamut)) {
-              report({ messageId: ERROR_SHADOW, data: { id: t.id, gamut: options.gamut }, node: t.source.node });
+              report({
+                messageId: ERROR_SHADOW,
+                data: { id: t.id, gamut: options.gamut },
+                node: t.source.node,
+                filename: t.source.filename,
+              });
             }
           }
           break;

package/src/lint/plugin-core/rules/no-type-on-alias.ts

@@ -0,0 +1,29 @@
+import { isAlias } from '@terrazzo/token-tools';
+import type { LintRule } from '../../../types.js';
+import { docsLink } from '../lib/docs.js';
+
+export const NO_TYPE_ON_ALIAS = 'core/no-type-on-alias';
+
+export const ERROR = 'ERROR';
+
+const rule: LintRule<typeof ERROR> = {
+  meta: {
+    messages: {
+      [ERROR]: 'Remove $type from aliased value.',
+    },
+    docs: {
+      description: 'If a $value is aliased it already has a $type defined.',
+      url: docsLink(NO_TYPE_ON_ALIAS),
+    },
+  },
+  defaultOptions: {},
+  create({ tokens, report }) {
+    for (const t of Object.values(tokens)) {
+      if (isAlias(t.originalValue!.$value as any) && t.originalValue?.$type) {
+        report({ messageId: ERROR, node: t.source.node, filename: t.source.filename });
+      }
+    }
+  },
+};
+
+export default rule;

package/src/lint/plugin-core/rules/required-modes.ts

@@ -55,6 +55,7 @@ const rule: LintRule<never, RuleRequiredModesOptions> = {
             report({
               message: `Token ${t.id}: missing required mode "${mode}"`,
               node: t.source.node,
+              filename: t.source.filename,
             });
           }
         }
@@ -63,6 +64,7 @@ const rule: LintRule<never, RuleRequiredModesOptions> = {
           report({
             message: `Match "${matchI}": no tokens matched ${JSON.stringify(match)}`,
             node: t.source.node,
+            filename: t.source.filename,
           });
         }
       }