blume 1.7.3 → 2.0.1

package/src/core/component-overrides.ts

@@ -1,25 +1,30 @@
 import { existsSync } from "node:fs";
 
-import { dirname, extname, isAbsolute, resolve } from "pathe";
+import { basename, dirname, extname, isAbsolute, join, resolve } from "pathe";
 import ts from "typescript";
 
+import { BlumeError } from "./diagnostics.ts";
 import type { HydrationMode } from "./schema.ts";
+import type { Diagnostic } from "./types.ts";
 
 /**
  * Static analysis of a user `components.ts`/`.tsx`.
  *
  * Astro can only hydrate a component it imports *statically by path*, so to honor
- * hydration on overrides (the `islands` group and `client:*` layout/mdx
- * descriptors) Blume needs each override's source path and client mode at
- * generate time — before Vite compiles anything. We read that here by parsing the
- * file with the TypeScript compiler API (never executing it, so `.astro`/React
+ * hydration on overrides Blume needs each override's source path and client mode
+ * at generate time — before Vite compiles anything. We read that here by parsing
+ * the file with the TypeScript compiler API (never executing it, so `.astro`/React
  * imports don't need a Node loader).
  *
- * Only statically-analyzable authoring is understood: a default export that is an
- * object literal or a `defineComponents({ ... })` call, with entries that are
- * imported identifiers, path strings, or `{ component, client, media }` object
- * literals. Anything else falls back to the runtime overrides object (which can
- * still render a static component, just not hydrate it).
+ * Only statically-analyzable authoring is accepted: a default export that is an
+ * object literal or a `defineComponents({ ... })` call, whose `mdx`/`layout`
+ * groups are object literals with entries that are imported identifiers, path
+ * strings, or `{ component, client, media }` object literals, and a relative
+ * or absolute path must name a file that exists. Anything else is a config
+ * error ({@link ComponentOverridesError}, `BLUME_COMPONENTS_INVALID`) naming the
+ * entry, its line, and the accepted forms — there is no runtime fallback, so an
+ * override that can't be planned never silently renders without hydration, and
+ * a missing file never surfaces as a bundler error inside the generated runtime.
  */
 
 export type OverrideFramework = "react" | "svelte" | "vue";
@@ -38,35 +43,36 @@ export interface OverrideImport {
 export interface NormalizedOverride {
   /** Present when the override should hydrate; drives the `client:*` directive. */
   client?: HydrationMode;
-  /**
-   * True when the value is a bare imported identifier, so the runtime overrides
-   * object already holds a usable component (no generated import needed for a
-   * non-hydrated entry). False for path strings and `{ component }` descriptors.
-   */
-  identifier: boolean;
   key: string;
   /** Media query for `client: "media"`. */
   media?: string;
-  /**
-   * How to obtain the component. `null` means it couldn't be resolved to a file,
-   * so the runtime overrides object is used (static render only).
-   */
-  source: OverrideImport | null;
+  /** How to obtain the component. */
+  source: OverrideImport;
 }
 
 export interface ComponentOverrideAnalysis {
-  islands: NormalizedOverride[];
   layout: NormalizedOverride[];
   mdx: NormalizedOverride[];
   warnings: string[];
 }
 
-const GROUPS = ["mdx", "layout", "islands"] as const;
+/** The analysis of a project with no `components.ts`. */
+export const emptyComponentOverrides = (): ComponentOverrideAnalysis => ({
+  layout: [],
+  mdx: [],
+  warnings: [],
+});
+
+const GROUPS = ["mdx", "layout"] as const;
 const GROUP_SET = new Set<string>(GROUPS);
 type Group = (typeof GROUPS)[number];
 
 const isGroup = (name: string): name is Group => GROUP_SET.has(name);
 
+/** The authoring forms an override accepts; the fix every rejection points at. */
+export const ACCEPTED_OVERRIDE_FORMS =
+  "Each override must be an imported identifier, a path string, or a `{ component, client, media }` object literal whose `component` is an imported identifier or a path string.";
+
 const FRAMEWORK_BY_EXT = new Map<string, OverrideFramework>([
   ["jsx", "react"],
   ["svelte", "svelte"],
@@ -100,29 +106,51 @@ const HYDRATION_MODES: ReadonlySet<string> = new Set<HydrationMode>([
   "visible",
 ]);
 
+const HYDRATION_MODE_LIST = '"load", "idle", "visible", "media", or "only"';
+
 const isHydrationMode = (value: string): value is HydrationMode =>
   HYDRATION_MODES.has(value);
 
 interface ImportBinding {
   /** Exported name: `"default"` or a named export. */
   imported: string;
+  /** The import statement, where a missing file is reported. */
+  node: ts.ImportDeclaration;
   specifier: string;
 }
 
+/** Why one entry was rejected, and the node it's about (for its line). */
+interface Rejection {
+  message: string;
+  /** A path that names no file: the fix is the path, not the entry's form. */
+  missingFile?: boolean;
+  node?: ts.Node;
+}
+
 /** An override's declared component before framework/path resolution. */
 interface RawDescriptor {
   client?: HydrationMode;
-  hadComponent: boolean;
   media?: string;
   source: OverrideImport | null;
 }
 
-const emptyAnalysis = (): ComponentOverrideAnalysis => ({
-  islands: [],
-  layout: [],
-  mdx: [],
-  warnings: [],
-});
+/** Everything one analysis pass needs to resolve and report an entry. */
+interface AnalysisContext {
+  dir: string;
+  /** Rejections collected across the file; thrown together at the end. */
+  errors: Rejection[];
+  imports: Map<string, ImportBinding>;
+  warnings: string[];
+}
+
+const reject = (
+  context: AnalysisContext,
+  message: string,
+  node?: ts.Node,
+  missingFile?: boolean
+): void => {
+  context.errors.push({ message, missingFile, node });
+};
 
 const propName = (name: ts.PropertyName): string | undefined =>
   ts.isIdentifier(name) || ts.isStringLiteral(name) ? name.text : undefined;
@@ -144,13 +172,18 @@ const addImportBindings = (
     return;
   }
   if (clause.name) {
-    map.set(clause.name.text, { imported: "default", specifier });
+    map.set(clause.name.text, {
+      imported: "default",
+      node: statement,
+      specifier,
+    });
   }
   const named = clause.namedBindings;
   if (named && ts.isNamedImports(named)) {
     for (const element of named.elements) {
       map.set(element.name.text, {
         imported: (element.propertyName ?? element.name).text,
+        node: statement,
         specifier,
       });
     }
@@ -188,16 +221,13 @@ const unwrapObject = (
   return undefined;
 };
 
-const findDefaultExportObject = (
+const findDefaultExport = (
   sourceFile: ts.SourceFile
-): ts.ObjectLiteralExpression | undefined => {
-  for (const statement of sourceFile.statements) {
-    if (ts.isExportAssignment(statement) && !statement.isExportEquals) {
-      return unwrapObject(statement.expression);
-    }
-  }
-  return undefined;
-};
+): ts.ExportAssignment | undefined =>
+  sourceFile.statements.find(
+    (statement): statement is ts.ExportAssignment =>
+      ts.isExportAssignment(statement) && !statement.isExportEquals
+  );
 
 const probeExtension = (base: string): string | null => {
   for (const extension of COMPONENT_EXTS) {
@@ -209,6 +239,30 @@ const probeExtension = (base: string): string | null => {
   return null;
 };
 
+// A `.js` specifier in a TypeScript file may name its `.ts`/`.tsx` source, as
+// Vite resolves it; the same holds for `.jsx` and `.mjs`.
+const SCRIPT_EXT = /\.(?:jsx?|mjs)$/u;
+const TS_SOURCE_EXTS = ["ts", "tsx", "mts"];
+
+/**
+ * Whether a local path names something the bundler can import: the file
+ * itself, the file with a component extension added, a folder's `index`, or
+ * the TypeScript source a `.js` specifier stands for.
+ */
+const resolvesLocally = (absolute: string): boolean => {
+  if (existsSync(absolute) || probeExtension(absolute)) {
+    return true;
+  }
+  if (probeExtension(join(absolute, "index"))) {
+    return true;
+  }
+  const base = absolute.replace(SCRIPT_EXT, "");
+  return (
+    base !== absolute &&
+    TS_SOURCE_EXTS.some((extension) => existsSync(`${base}.${extension}`))
+  );
+};
+
 /** Resolve a module specifier to a wrapper-importable path + framework. */
 const toImport = (
   specifier: string,
@@ -237,88 +291,191 @@ const toImport = (
   };
 };
 
+/**
+ * Resolve a specifier to its import, or record that the file it names doesn't
+ * exist. A bare package specifier is left to the bundler.
+ */
+const sourceFor = (
+  specifier: string,
+  imported: string,
+  label: string,
+  node: ts.Node,
+  context: AnalysisContext
+): OverrideImport | null => {
+  const local = specifier.startsWith(".") || isAbsolute(specifier);
+  if (local && !resolvesLocally(resolve(context.dir, specifier))) {
+    reject(
+      context,
+      `${label} points at "${specifier}", but no file exists there; fix the path or restore the file.`,
+      node,
+      true
+    );
+    return null;
+  }
+  return toImport(specifier, imported, context.dir);
+};
+
+/**
+ * Resolve an identifier to the import it names, or record why it can't be: a
+ * local binding (a `const`, a function declared in the file) has no source path
+ * a wrapper could import.
+ */
 const resolveIdentifier = (
   name: string,
-  imports: Map<string, ImportBinding>,
-  dir: string
+  label: string,
+  node: ts.Node,
+  context: AnalysisContext
 ): OverrideImport | null => {
-  const binding = imports.get(name);
-  return binding ? toImport(binding.specifier, binding.imported, dir) : null;
+  const binding = context.imports.get(name);
+  if (binding) {
+    return sourceFor(
+      binding.specifier,
+      binding.imported,
+      label,
+      binding.node,
+      context
+    );
+  }
+  reject(
+    context,
+    `${label} refers to "${name}", which isn't imported in this file; import the component from its file.`,
+    node
+  );
+  return null;
 };
 
+const ALLOWED_FIELDS =
+  "only `component`, `client`, and `media` are allowed in a descriptor.";
+
 /** Fold one descriptor-object property into the accumulating descriptor. */
 const applyDescriptorProperty = (
   descriptor: RawDescriptor,
   property: ts.ObjectLiteralElementLike,
-  imports: Map<string, ImportBinding>,
-  dir: string
+  label: string,
+  context: AnalysisContext
 ): void => {
   if (ts.isShorthandPropertyAssignment(property)) {
     if (property.name.text === "component") {
-      descriptor.hadComponent = true;
-      descriptor.source = resolveIdentifier(property.name.text, imports, dir);
+      descriptor.source = resolveIdentifier(
+        property.name.text,
+        `${label}'s \`component\``,
+        property,
+        context
+      );
+      return;
+    }
+    const shorthand = property.name.text;
+    if (shorthand === "client" || shorthand === "media") {
+      reject(
+        context,
+        `${label} writes \`${shorthand}\` as a shorthand property; only \`component\` may be shorthand, \`${shorthand}\` must be a string literal.`,
+        property
+      );
+      return;
     }
+    reject(
+      context,
+      `${label} has a \`${shorthand}\` field; ${ALLOWED_FIELDS}`,
+      property
+    );
     return;
   }
   if (!ts.isPropertyAssignment(property)) {
+    reject(
+      context,
+      `${label} contains a spread, method, or accessor; write it as a plain \`{ component, client, media }\` object literal.`,
+      property
+    );
     return;
   }
   const name = propName(property.name);
   const init = property.initializer;
   if (name === "component") {
-    descriptor.hadComponent = true;
     if (ts.isStringLiteral(init)) {
-      descriptor.source = toImport(init.text, "default", dir);
+      descriptor.source = sourceFor(
+        init.text,
+        "default",
+        `${label}'s \`component\``,
+        init,
+        context
+      );
     } else if (ts.isIdentifier(init)) {
-      descriptor.source = resolveIdentifier(init.text, imports, dir);
+      descriptor.source = resolveIdentifier(
+        init.text,
+        `${label}'s \`component\``,
+        init,
+        context
+      );
+    } else {
+      reject(
+        context,
+        `${label}'s \`component\` must be an imported identifier or a path string.`,
+        init
+      );
     }
-  } else if (
-    name === "client" &&
-    ts.isStringLiteral(init) &&
-    isHydrationMode(init.text)
-  ) {
-    descriptor.client = init.text;
-  } else if (name === "media" && ts.isStringLiteral(init)) {
-    descriptor.media = init.text;
+  } else if (name === "client") {
+    if (ts.isStringLiteral(init) && isHydrationMode(init.text)) {
+      descriptor.client = init.text;
+    } else {
+      reject(
+        context,
+        `${label}'s \`client\` must be a string literal: ${HYDRATION_MODE_LIST}.`,
+        init
+      );
+    }
+  } else if (name === "media") {
+    if (ts.isStringLiteral(init)) {
+      descriptor.media = init.text;
+    } else {
+      reject(context, `${label}'s \`media\` must be a string literal.`, init);
+    }
+  } else {
+    reject(
+      context,
+      `${label} has a \`${name ?? property.name.getText()}\` field; ${ALLOWED_FIELDS}`,
+      property
+    );
   }
 };
 
+/**
+ * Read a `{ component, client, media }` descriptor. Returns null (after
+ * recording the reason) when it can't be planned.
+ */
 const readDescriptor = (
   object: ts.ObjectLiteralExpression,
-  imports: Map<string, ImportBinding>,
-  dir: string
-): RawDescriptor => {
-  const descriptor: RawDescriptor = { hadComponent: false, source: null };
+  label: string,
+  context: AnalysisContext
+): RawDescriptor | null => {
+  const descriptor: RawDescriptor = { source: null };
+  const before = context.errors.length;
+  let hadComponent = false;
   for (const property of object.properties) {
-    applyDescriptorProperty(descriptor, property, imports, dir);
+    if (property.name && propName(property.name) === "component") {
+      hadComponent = true;
+    }
+    applyDescriptorProperty(descriptor, property, label, context);
+  }
+  if (!hadComponent) {
+    reject(
+      context,
+      `${label} is an object literal without a \`component\` field.`,
+      object
+    );
   }
-  return descriptor;
+  return context.errors.length === before ? descriptor : null;
 };
 
 /** Apply cross-cutting validation and produce the final normalized override. */
 const finalize = (
   key: string,
-  group: Group,
   descriptor: RawDescriptor,
   label: string,
-  identifier: boolean,
   warnings: string[]
 ): NormalizedOverride | null => {
   const { client, media, source } = descriptor;
-
-  if (group === "islands") {
-    if (!source) {
-      warnings.push(
-        `Island override "${key}" couldn't be resolved to a file. Reference it by an imported component or a path string with an extension.`
-      );
-      return null;
-    }
-    if (!source.framework) {
-      warnings.push(
-        `Island override "${key}" (${label}) is not a React, Vue, or Svelte component; only framework components can be islands.`
-      );
-      return null;
-    }
+  if (!source) {
+    return null;
   }
 
   if (client === "media" && !media) {
@@ -327,19 +484,19 @@ const finalize = (
     );
   }
 
-  if (client === "only" && source && !source.framework) {
+  if (client === "only" && !source.framework) {
     warnings.push(
       `Override "${key}" uses client: "only" but its framework couldn't be inferred; reference a .tsx/.jsx/.vue/.svelte file.`
     );
   }
 
-  if (!client && source?.framework) {
+  if (!client && source.framework) {
     warnings.push(
       `Override "${key}" points to a ${FRAMEWORK_LABEL[source.framework]} component (${label}) but has no hydration mode, so it renders as static HTML with no interactivity. Add one, e.g. \`${key}: { component: ${JSON.stringify(label)}, client: "load" }\`.`
     );
   }
 
-  const normalized: NormalizedOverride = { identifier, key, source };
+  const normalized: NormalizedOverride = { key, source };
   if (client) {
     normalized.client = client;
   }
@@ -349,37 +506,48 @@ const finalize = (
   return normalized;
 };
 
+/** Normalize one `key: value` entry of a group, or record why it's rejected. */
 const normalizeEntry = (
   entry: ts.ObjectLiteralElementLike,
   group: Group,
-  imports: Map<string, ImportBinding>,
-  dir: string,
-  warnings: string[]
+  context: AnalysisContext
 ): NormalizedOverride | null => {
-  const defaultClient: HydrationMode | undefined =
-    group === "islands" ? "visible" : undefined;
+  const { warnings } = context;
 
   if (ts.isShorthandPropertyAssignment(entry)) {
     const name = entry.name.text;
     return finalize(
       name,
-      group,
-      {
-        client: defaultClient,
-        hadComponent: true,
-        source: resolveIdentifier(name, imports, dir),
-      },
+      { source: resolveIdentifier(name, `${group}.${name}`, entry, context) },
       name,
-      true,
       warnings
     );
   }
 
-  if (!ts.isPropertyAssignment(entry)) {
+  if (ts.isSpreadAssignment(entry)) {
+    reject(
+      context,
+      `${group} contains a spread (\`...${entry.expression.getText()}\`); list each override explicitly.`,
+      entry
+    );
     return null;
   }
   const key = propName(entry.name);
   if (!key) {
+    reject(
+      context,
+      `${group} has an entry with a computed key (\`${entry.name.getText()}\`); keys must be plain names.`,
+      entry
+    );
+    return null;
+  }
+  const label = `${group}.${key}`;
+  if (!ts.isPropertyAssignment(entry)) {
+    reject(
+      context,
+      `${label} is a method or accessor, which Blume can't analyze statically.`,
+      entry
+    );
     return null;
   }
   const value = entry.initializer;
@@ -387,100 +555,155 @@ const normalizeEntry = (
   if (ts.isIdentifier(value)) {
     return finalize(
       key,
-      group,
-      {
-        client: defaultClient,
-        hadComponent: true,
-        source: resolveIdentifier(value.text, imports, dir),
-      },
+      { source: resolveIdentifier(value.text, label, entry, context) },
       value.text,
-      true,
       warnings
     );
   }
   if (ts.isStringLiteral(value)) {
     return finalize(
       key,
-      group,
-      {
-        client: defaultClient,
-        hadComponent: true,
-        source: toImport(value.text, "default", dir),
-      },
+      { source: sourceFor(value.text, "default", label, value, context) },
       value.text,
-      false,
       warnings
     );
   }
   if (ts.isObjectLiteralExpression(value)) {
-    const descriptor = readDescriptor(value, imports, dir);
-    if (!descriptor.hadComponent) {
-      warnings.push(
-        `Override "${key}" is an object without a \`component\` field; expected \`{ component, client }\`.`
-      );
-      return null;
-    }
-    if (!descriptor.source) {
-      warnings.push(
-        `Override "${key}"'s \`component\` couldn't be resolved to a file. Reference an imported component or a path string with an extension.`
-      );
-      return null;
-    }
-    return finalize(
-      key,
-      group,
-      { ...descriptor, client: descriptor.client ?? defaultClient },
-      key,
-      false,
-      warnings
-    );
+    const descriptor = readDescriptor(value, label, context);
+    return descriptor ? finalize(key, descriptor, key, warnings) : null;
   }
 
-  // An inline function/expression: keep it on the runtime object (static only).
-  return { identifier: false, key, source: null };
+  reject(
+    context,
+    `${label} is an inline expression, which Blume can't analyze statically.`,
+    entry
+  );
+  return null;
 };
 
-/** Normalize one top-level `{ mdx | layout | islands }` group into `result`. */
+/** Normalize one top-level `{ mdx | layout }` group into `result`. */
 const collectGroupOverrides = (
   property: ts.ObjectLiteralElementLike,
-  imports: Map<string, ImportBinding>,
-  dir: string,
+  context: AnalysisContext,
   result: ComponentOverrideAnalysis
 ): void => {
-  if (!ts.isPropertyAssignment(property)) {
+  if (ts.isSpreadAssignment(property)) {
+    reject(
+      context,
+      `The top-level object contains a spread (\`...${property.expression.getText()}\`); list \`mdx\` and \`layout\` explicitly.`,
+      property
+    );
     return;
   }
   const name = propName(property.name);
+  if (name === "islands") {
+    reject(
+      context,
+      'The `islands` group was folded into `mdx`: move each entry there and give it a `client` mode, e.g. `mdx: { Counter: { component: Counter, client: "visible" } }`.',
+      property
+    );
+    return;
+  }
+  if (!(name && isGroup(name))) {
+    reject(
+      context,
+      `\`${name ?? property.name.getText()}\` isn't an override group; use \`mdx\` or \`layout\`.`,
+      property
+    );
+    return;
+  }
   if (
-    !(name && isGroup(name)) ||
+    !ts.isPropertyAssignment(property) ||
     !ts.isObjectLiteralExpression(property.initializer)
   ) {
+    reject(
+      context,
+      `\`${name}\` must be an object literal of overrides.`,
+      property
+    );
     return;
   }
   for (const entry of property.initializer.properties) {
-    const normalized = normalizeEntry(
-      entry,
-      name,
-      imports,
-      dir,
-      result.warnings
-    );
+    const normalized = normalizeEntry(entry, name, context);
     if (normalized) {
       result[name].push(normalized);
     }
   }
 };
 
+/**
+ * A `components.ts` Blume can't plan. The diagnostic lists every rejected entry
+ * at once (at the first one's line); `issues` holds each on its own, with its
+ * line, for a caller that reports them one by one (`blume upgrade`).
+ */
+export class ComponentOverridesError extends BlumeError {
+  readonly issues: Diagnostic[];
+
+  constructor(diagnostic: Diagnostic, issues: Diagnostic[]) {
+    super(diagnostic);
+    this.name = "ComponentOverridesError";
+    this.issues = issues;
+  }
+}
+
+/** A rejection as a diagnostic, at its node's line when it has one. */
+const rejectionDiagnostic = (
+  filePath: string,
+  sourceFile: ts.SourceFile,
+  rejection: Rejection
+): Diagnostic => {
+  const position = rejection.node
+    ? sourceFile.getLineAndCharacterOfPosition(
+        rejection.node.getStart(sourceFile)
+      )
+    : undefined;
+  return {
+    code: "BLUME_COMPONENTS_INVALID",
+    column: position && position.character + 1,
+    file: filePath,
+    line: position && position.line + 1,
+    message: rejection.message,
+    severity: "error",
+    suggestion: rejection.missingFile ? undefined : ACCEPTED_OVERRIDE_FORMS,
+  };
+};
+
+const invalidOverrides = (
+  filePath: string,
+  sourceFile: ts.SourceFile,
+  rejections: Rejection[]
+): ComponentOverridesError => {
+  const issues = rejections.map((rejection) =>
+    rejectionDiagnostic(filePath, sourceFile, rejection)
+  );
+  const first = issues.find((issue) => issue.line !== undefined);
+  return new ComponentOverridesError(
+    {
+      code: "BLUME_COMPONENTS_INVALID",
+      column: first?.column,
+      file: filePath,
+      line: first?.line,
+      message: `${basename(filePath)} has ${rejections.length} override(s) Blume can't plan:\n${rejections.map((rejection) => `  - ${rejection.message}`).join("\n")}`,
+      severity: "error",
+      suggestion: rejections.every((rejection) => rejection.missingFile)
+        ? undefined
+        : ACCEPTED_OVERRIDE_FORMS,
+    },
+    issues
+  );
+};
+
 /**
  * Parse a user `components.ts`/`.tsx` and return its normalized overrides. Never
- * executes the file. On a parse failure or unrecognized shape, returns empty
- * groups so generation falls back to the plain runtime overrides object.
+ * executes the file. Throws a `BLUME_COMPONENTS_INVALID`
+ * {@link ComponentOverridesError} listing every entry that isn't one of the
+ * accepted forms or points at a file that doesn't exist.
  */
 export const analyzeComponentOverrides = (
   source: string,
   filePath: string
 ): ComponentOverrideAnalysis => {
-  const result = emptyAnalysis();
+  const result = emptyComponentOverrides();
   const sourceFile = ts.createSourceFile(
     filePath,
     source,
@@ -489,17 +712,39 @@ export const analyzeComponentOverrides = (
     filePath.endsWith("tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS
   );
 
-  const object = findDefaultExportObject(sourceFile);
+  const exported = findDefaultExport(sourceFile);
+  if (!exported) {
+    throw invalidOverrides(filePath, sourceFile, [
+      {
+        message:
+          "No default export was found; export `defineComponents({ mdx, layout })` (or a plain object literal) as the default.",
+      },
+    ]);
+  }
+  const object = unwrapObject(exported.expression);
   if (!object) {
-    return result;
+    throw invalidOverrides(filePath, sourceFile, [
+      {
+        message:
+          "The default export isn't an object literal or a `defineComponents({ ... })` call.",
+        node: exported,
+      },
+    ]);
   }
 
-  const imports = collectImports(sourceFile);
-  const dir = dirname(filePath);
+  const context: AnalysisContext = {
+    dir: dirname(filePath),
+    errors: [],
+    imports: collectImports(sourceFile),
+    warnings: result.warnings,
+  };
 
   for (const property of object.properties) {
-    collectGroupOverrides(property, imports, dir, result);
+    collectGroupOverrides(property, context, result);
   }
 
+  if (context.errors.length > 0) {
+    throw invalidOverrides(filePath, sourceFile, context.errors);
+  }
   return result;
 };