@timber-js/app 0.2.0-alpha.185 → 0.2.0-alpha.187

package/src/routing/export-detect.ts

@@ -20,7 +20,13 @@ interface AstNode {
     exportKind?: string;
   }>;
   id?: { name: string };
-  declarations?: Array<{ id?: { name: string } }>;
+  declarations?: Array<{ id?: { name: string }; init?: AstNode }>;
+  /** Set on re-exports: `export { X } from './y'`. Absent on local exports. */
+  source?: { value?: string } | null;
+  /** Set on runtime-transparent wrappers: `X as T`, `X satisfies T`, `(X)`, `X!`. */
+  expression?: AstNode;
+  /** Set on `Identifier` nodes. */
+  name?: string;
 }
 
 interface ProgramNode {
@@ -71,19 +77,41 @@ function collectNamedExports(program: ProgramNode): Set<string> {
   return names;
 }
 
+/**
+ * The specifier exporting a *runtime* default from this statement, if any.
+ *
+ * Type-only exports erase, so they are not default exports at runtime — and
+ * TypeScript spells that two ways, on two different nodes: `export type { X as
+ * default }` marks the **statement**, `export { type X as default }` marks the
+ * **specifier**. Both have to be checked, or a type alias reads as a component:
+ * a status file whose only default is a type has nothing for the error boundary
+ * to receive (the renderer's `mod?.default` skips it), so treating it as one
+ * would fail a build over a file that cannot break anything.
+ *
+ * One implementation because two callers must agree on what "has a default
+ * export" means: `hasDefaultExport` decides whether to warn that a page has
+ * none, and `fileDefaultExportIsLocalValue` decides whether to fail the build.
+ */
+function defaultSpecifier(stmt: AstNode): NonNullable<AstNode['specifiers']>[number] | null {
+  if (stmt.type !== 'ExportNamedDeclaration' || !stmt.specifiers) return null;
+  if (stmt.exportKind === 'type') return null;
+  for (const spec of stmt.specifiers) {
+    if (spec.exportKind === 'type') continue;
+    if (spec.exported?.name === 'default') return spec;
+  }
+  return null;
+}
+
 /**
  * Check whether a program has a default export.
  * Handles: `export default ...`, `export { X as default }`,
- * `export { default } from '...'`.
+ * `export { default } from '...'`. Type-only defaults do not count —
+ * see `defaultSpecifier`.
  */
 function hasDefaultExport(program: ProgramNode): boolean {
   for (const stmt of program.body) {
     if (stmt.type === 'ExportDefaultDeclaration') return true;
-    if (stmt.type === 'ExportNamedDeclaration' && stmt.specifiers) {
-      for (const spec of stmt.specifiers) {
-        if (spec.exported?.name === 'default') return true;
-      }
-    }
+    if (defaultSpecifier(stmt)) return true;
   }
   return false;
 }
@@ -152,6 +180,122 @@ export function fileHasDefaultExport(filePath: string): boolean {
   }
 }
 
+/** Node types whose value is unambiguously constructed by this module. */
+const FUNCTION_LIKE = new Set([
+  'FunctionDeclaration',
+  'FunctionExpression',
+  'ArrowFunctionExpression',
+  'ClassDeclaration',
+  'ClassExpression',
+]);
+
+/**
+ * Expression wrappers that erase at runtime and so cannot change where a value
+ * was constructed: `X as T`, `X satisfies T`, `<T>X`, `X!`, `X<T>`, `(X)`.
+ */
+const TRANSPARENT_WRAPPERS = new Set([
+  'TSAsExpression',
+  'TSSatisfiesExpression',
+  'TSTypeAssertion',
+  'TSNonNullExpression',
+  'TSInstantiationExpression',
+  'ParenthesizedExpression',
+]);
+
+/**
+ * Strip runtime-transparent wrappers so the node underneath can be classified.
+ *
+ * Without this, `(() => <h1 />) satisfies React.FC` reads as a
+ * `TSSatisfiesExpression` rather than the arrow function it compiles to, and a
+ * provably-local component is misread as one whose origin cannot be
+ * determined — turning a build error into a warning.
+ */
+function unwrapTransparent(node: AstNode): AstNode {
+  let current = node;
+  while (TRANSPARENT_WRAPPERS.has(current.type) && current.expression) {
+    current = current.expression;
+  }
+  return current;
+}
+
+/**
+ * Whether `name` is bound at module top level to a function or class written
+ * in this file. An imported binding can never match: imports are
+ * `ImportDeclaration` specifiers, not function/class/variable declarations,
+ * and a module-level name cannot be both.
+ */
+function bindsLocalFunction(program: ProgramNode, name: string): boolean {
+  for (const stmt of program.body) {
+    // `export function X() {}` binds X locally too — unwrap the export.
+    const decl = stmt.type === 'ExportNamedDeclaration' ? stmt.declaration : stmt;
+    if (!decl) continue;
+    if (
+      (decl.type === 'FunctionDeclaration' || decl.type === 'ClassDeclaration') &&
+      decl.id?.name === name
+    ) {
+      return true;
+    }
+    if (decl.type === 'VariableDeclaration') {
+      for (const d of decl.declarations ?? []) {
+        if (d.id?.name === name && d.init && FUNCTION_LIKE.has(unwrapTransparent(d.init).type)) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+
+/**
+ * Whether the default export is *provably* a value constructed by this module:
+ * `export default function/class/() => {}`, or a name bound to a function or
+ * class declared here — whether it leaves via `export default Name` or
+ * `export { Name as default }`. Both spellings are the same fact about where
+ * the value was built, so both must answer the same way.
+ *
+ * This is the sound half of "is this a server component?". A file with no
+ * `'use client'` directive whose default export is built here is a server
+ * component, full stop. Everything else — `export { default } from
+ * './client-thing'`, `export default Imported`, `export default memo(X)`,
+ * an unparseable file — returns false, because the exported value may have
+ * been minted in a module that *does* carry the directive. Callers must not
+ * infer "server component" from a missing directive alone.
+ */
+export function fileDefaultExportIsLocalValue(filePath: string): boolean {
+  if (!existsSync(filePath)) return false;
+  try {
+    const source = readFileCached(filePath);
+    const program = tryParse(source);
+    if (!program) return false;
+    for (const stmt of program.body) {
+      if (stmt.type === 'ExportDefaultDeclaration') {
+        const decl = stmt.declaration && unwrapTransparent(stmt.declaration);
+        if (!decl) return false;
+        if (FUNCTION_LIKE.has(decl.type)) return true;
+        if (decl.type === 'Identifier' && decl.name) {
+          return bindsLocalFunction(program, decl.name);
+        }
+        return false;
+      }
+
+      // `export { Name as default }` — the same default export by another
+      // spelling. `hasDefaultExport` already counts it, so an analysis that
+      // skipped it here would let the exact defect this powers slip through
+      // as a warning.
+      const spec = defaultSpecifier(stmt);
+      if (spec) {
+        // `export { X as default } from './client-thing'` re-exports another
+        // module's value — the directive governing it lives over there.
+        if (stmt.source) return false;
+        return spec.local?.name ? bindsLocalFunction(program, spec.local.name) : false;
+      }
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+
 /**
  * Check if a file has any `export * from '...'` declarations.
  * Returns false if the file doesn't exist or can't be parsed.