@timber-js/app 0.2.0-alpha.18 → 0.2.0-alpha.180

package/src/plugins/static-build.ts

@@ -2,34 +2,28 @@
  * timber-static-build — Vite sub-plugin for static output mode.
  *
  * When `output: 'static'` is set in timber.config.ts, this plugin:
- * 1. Validates that no dynamic APIs (cookies(), headers()) are used
- * 2. When client JavaScript is disabled, rejects 'use client' and 'use server' directives
- * 3. Coordinates build-time rendering of all pages
+ * 1. Validates that no dynamic APIs (getCookies(), getHeaders()) are used
+ * 2. Coordinates build-time rendering of all pages
  *
  * Design doc: design/15-future-prerendering.md
  */
 
 import type { Plugin } from 'vite';
-import type { PluginContext } from '#/index.js';
-import { detectFileDirective } from '#/utils/directive-parser.js';
+import type { PluginContext } from '../plugin-context.js';
 
 // ---------------------------------------------------------------------------
 // Types
 // ---------------------------------------------------------------------------
 
 export interface StaticValidationError {
-  type: 'dynamic-api' | 'nojs-directive';
+  type: 'dynamic-api';
   file: string;
   message: string;
   line?: number;
 }
 
-export interface StaticOptions {
-  clientJavascriptDisabled: boolean;
-}
-
 // ---------------------------------------------------------------------------
-// Detection: dynamic APIs (cookies, headers)
+// Detection: dynamic APIs (getCookies, getHeaders, and legacy cookies/headers)
 // ---------------------------------------------------------------------------
 
 /**
@@ -39,12 +33,14 @@ export interface StaticOptions {
  * We detect both import-level and call-level usage.
  */
 const DYNAMIC_API_PATTERNS: Array<{ pattern: RegExp; name: string }> = [
+  { pattern: /\bgetCookieJar\s*\(/, name: 'getCookieJar()' },
+  { pattern: /\bgetHeaders\s*\(/, name: 'getHeaders()' },
   { pattern: /\bcookies\s*\(/, name: 'cookies()' },
   { pattern: /\bheaders\s*\(/, name: 'headers()' },
 ];
 
 /**
- * Detect usage of dynamic per-request APIs (cookies(), headers())
+ * Detect usage of dynamic per-request APIs (getCookies(), getHeaders())
  * that cannot work at build time in static mode.
  *
  * Returns an array of validation errors.
@@ -78,78 +74,6 @@ export function detectDynamicApis(code: string, fileId: string): StaticValidatio
   return errors;
 }
 
-// ---------------------------------------------------------------------------
-// Detection: 'use client' / 'use server' directives (clientJavascript disabled)
-// ---------------------------------------------------------------------------
-
-/**
- * Detect 'use client' and 'use server' directives using AST-based parsing.
- * When client JavaScript is disabled, both are hard build errors — no React
- * runtime or server actions are allowed in the output.
- *
- * When client JavaScript is enabled, these are allowed (client components
- * hydrate, server actions get extracted to API endpoints).
- */
-export function detectDirectives(
-  code: string,
-  fileId: string,
-  options: StaticOptions
-): StaticValidationError[] {
-  if (!options.clientJavascriptDisabled) return [];
-
-  const errors: StaticValidationError[] = [];
-
-  const clientDirective = detectFileDirective(code, ['use client']);
-  if (clientDirective) {
-    errors.push({
-      type: 'nojs-directive',
-      file: fileId,
-      message:
-        `'use client' is not allowed when client JavaScript is disabled (clientJavascript: false). ` +
-        `This mode produces zero JavaScript — client components cannot exist.`,
-      line: clientDirective.line,
-    });
-  }
-
-  const serverDirective = detectFileDirective(code, ['use server']);
-  if (serverDirective) {
-    errors.push({
-      type: 'nojs-directive',
-      file: fileId,
-      message:
-        `'use server' is not allowed when client JavaScript is disabled (clientJavascript: false). ` +
-        `This mode produces zero JavaScript — server actions cannot exist.`,
-      line: serverDirective.line,
-    });
-  }
-
-  return errors;
-}
-
-// ---------------------------------------------------------------------------
-// Combined validation
-// ---------------------------------------------------------------------------
-
-/**
- * Run all static mode validations on a source file.
- *
- * Combines:
- * - Dynamic API detection (cookies, headers) — always in static mode
- * - Directive detection ('use client', 'use server') — only when client JS is disabled
- */
-export function validateStaticMode(
-  code: string,
-  fileId: string,
-  options: StaticOptions
-): StaticValidationError[] {
-  const errors: StaticValidationError[] = [];
-
-  errors.push(...detectDynamicApis(code, fileId));
-  errors.push(...detectDirectives(code, fileId, options));
-
-  return errors;
-}
-
 // ---------------------------------------------------------------------------
 // Vite Plugin
 // ---------------------------------------------------------------------------
@@ -163,9 +87,6 @@ export function validateStaticMode(
  * - transform: Validates source files for static mode violations
  */
 export function timberStaticBuild(ctx: PluginContext): Plugin {
-  const isStatic = ctx.config.output === 'static';
-  const clientJavascriptDisabled = ctx.clientJavascript.disabled;
-
   return {
     name: 'timber-static-build',
 
@@ -173,10 +94,14 @@ export function timberStaticBuild(ctx: PluginContext): Plugin {
      * Validate source files during transform.
      *
      * In static mode, we check every app/ file for:
-     * - Dynamic API usage (cookies(), headers()) → build error
-     * - When client JS disabled: 'use client' / 'use server' directives → build error
+     * - Dynamic API usage (getCookies(), getHeaders()) → build error
      */
     transform(code: string, id: string) {
+      // Read ctx.config lazily inside the hook — not at plugin construction
+      // time — so file-based config from timber.config.ts is respected.
+      // See TIM-451.
+      const isStatic = ctx.config.output === 'static';
+
       // Only active in static mode
       if (!isStatic) return null;
 
@@ -189,7 +114,7 @@ export function timberStaticBuild(ctx: PluginContext): Plugin {
       // Only check JS/TS files
       if (!/\.[jt]sx?$/.test(id)) return null;
 
-      const errors = validateStaticMode(code, id, { clientJavascriptDisabled });
+      const errors = detectDynamicApis(code, id);
 
       if (errors.length > 0) {
         // Format all errors into a single build error message

package/src/routing/codegen-shared.ts

@@ -0,0 +1,115 @@
+/**
+ * Shared codegen helpers — import-path computation, codec chain type
+ * builder, and searchParams type formatter.
+ *
+ * Extracted from `codegen.ts` so `link-codegen.ts` can use the same
+ * helpers without a cyclic import.
+ */
+
+import { relative, posix } from 'node:path';
+import type { ParamEntry, RouteEntry } from './codegen-types.js';
+
+/**
+ * Compute a relative import specifier for a codec/page file, stripping
+ * the .ts/.tsx extension and resolving against the codegen output dir.
+ */
+export function codecImportPath(codecFilePath: string, importBase: string | undefined): string {
+  const absPath = codecFilePath.replace(/\.(ts|tsx)$/, '');
+  if (importBase) {
+    return './' + relative(importBase, absPath).replace(/\\/g, '/');
+  }
+  return './' + posix.basename(absPath);
+}
+
+/** Name of the shared helper type emitted at the top of the .d.ts. */
+export const RESOLVE_SEGMENT_FIELD_TYPE_NAME = '_TimberResolveSegmentField';
+
+/**
+ * Helper type emitted once at the top of the generated `.d.ts` and
+ * referenced by every codec-chain conditional. Without this shared
+ * helper, the inline expansion would duplicate the fallback branch on
+ * every step and grow O(2^N) in chain depth (a single deep nested route
+ * could blow up the file size and TS performance). With the helper,
+ * each step reuses the named type and growth is O(N).
+ *
+ * The helper is a 2-arg conditional: given a typeof import expression
+ * (`Def`), a key (`K`), and a fallback (`F`), it returns `T[K]` if
+ * `Def extends ParamsDefinition<T>` and `K extends keyof T`, otherwise
+ * `F`. The codec chain composes calls to this helper.
+ */
+export function emitResolveSegmentFieldHelper(): string {
+  return [
+    `type ${RESOLVE_SEGMENT_FIELD_TYPE_NAME}<Def, K extends string, F> =`,
+    `  Def extends import('@timber-js/app/segment-params').ParamsDefinition<infer T>`,
+    `    ? K extends keyof T ? T[K] : F`,
+    `    : F;`,
+  ].join('\n');
+}
+
+/**
+ * Build a TypeScript type expression that resolves a single param's
+ * codec by walking a chain of params.ts files in priority order.
+ *
+ * Each entry in the chain emits one application of the shared
+ * `_TimberResolveSegmentField` helper type. Composing N applications
+ * grows linearly with chain depth (O(N) characters), unlike an inline
+ * conditional that would duplicate the fallback in each branch and
+ * grow O(2^N).
+ *
+ * The closest match (position 0 in the chain) is checked first; if its
+ * `segmentParams` definition declares the key, its inferred type wins.
+ * Otherwise we fall through to the next entry, and finally to the
+ * provided fallback. See TIM-834.
+ */
+export function buildCodecChainType(
+  p: ParamEntry,
+  importBase: string | undefined,
+  fallback: string
+): string {
+  const files = p.codecFilePaths;
+  if (!files || files.length === 0) return fallback;
+  const key = JSON.stringify(p.name);
+  // Compose helper applications inside-out so the closest entry
+  // (files[0]) ends up as the OUTERMOST application. Each application
+  // adds a constant-size wrapper around the running fallback.
+  let inner = fallback;
+  for (let i = files.length - 1; i >= 0; i--) {
+    const importPath = codecImportPath(files[i], importBase);
+    inner = `${RESOLVE_SEGMENT_FIELD_TYPE_NAME}<(typeof import('${importPath}'))['segmentParams'], ${key}, ${inner}>`;
+  }
+  return inner;
+}
+
+/**
+ * Build a TypeScript type expression for a single param using the global
+ * schema's InferCodecType. Falls back to the param's base type when
+ * schema doesn't declare this param (schemas are opt-in per key).
+ *
+ * Uses `infer` to extract the codec value rather than direct indexing
+ * because TypeScript doesn't narrow index validity inside a conditional
+ * type's true branch — `typeof schema.segmentParams[K]` produces TS2538
+ * even when the condition proves K is a valid key. In .d.ts files that
+ * error is suppressed and the type silently becomes `any`.
+ */
+export function buildSchemaParamType(p: ParamEntry, fallback?: string): string {
+  const key = JSON.stringify(p.bracketName);
+  const fb = fallback ?? p.type;
+  return `typeof schema['segmentParams'] extends Record<${key}, infer V> ? InferCodecType<V> : ${fb}`;
+}
+
+/**
+ * Format the searchParams type for a route entry.
+ *
+ * When a page.tsx (or params.ts) exports searchParams, we reference its
+ * inferred type via an import type. The import path is relative to
+ * `importBase` (the directory where the .d.ts will be written). When
+ * importBase is undefined, falls back to a bare relative path.
+ */
+export function formatSearchParamsType(route: RouteEntry, importBase?: string): string {
+  if (route.hasSearchParams && route.searchParamsPagePath) {
+    const importPath = codecImportPath(route.searchParamsPagePath, importBase);
+    // Extract the type from the named 'searchParams' export of the page module.
+    return `(typeof import('${importPath}'))['searchParams'] extends import('@timber-js/app/search-params').SearchParamsDefinition<infer T> ? T : never`;
+  }
+  return '{}';
+}

package/src/routing/codegen-types.ts

@@ -0,0 +1,65 @@
+/**
+ * Shared types for route codegen modules.
+ *
+ * Lives in its own file so `link-codegen.ts` and `codegen.ts` can import
+ * the same `RouteEntry` / `ParamEntry` shapes without a cyclic
+ * dependency between the two.
+ */
+
+/** A single route entry extracted from the segment tree. */
+export interface RouteEntry {
+  /** URL path pattern (e.g. "/products/[id]") */
+  urlPath: string;
+  /** Full tree path including groups and slots (e.g. "/(browse)/[artistSlug]/@shows/[year]").
+   *  Uniquely identifies a segment — unlike urlPath which strips groups/slots. */
+  segmentPath: string;
+  /** Accumulated params from all ancestor dynamic segments */
+  params: ParamEntry[];
+  /** Whether the page.tsx exports searchParams */
+  hasSearchParams: boolean;
+  /** Absolute path to the page file that exports searchParams (for import paths) */
+  searchParamsPagePath?: string;
+  /** Whether this is an API route (route.ts) vs page route */
+  isApiRoute: boolean;
+  /** Whether this entry lives inside a parallel slot (@name). Slot entries
+   *  share their parent's urlPath — urlPath-keyed emissions dedupe them,
+   *  preferring the non-slot entry. segmentPath-keyed emissions keep all. */
+  isSlotRoute?: boolean;
+  /** Whether a global schema (app/schema.ts) exists for this app */
+  hasSchema?: boolean;
+}
+
+export interface ParamEntry {
+  name: string;
+  /** Bracket-wrapped segment name as it appears in the filesystem and schema.
+   *  e.g. '[id]', '[...slug]', '[[...slug]]' */
+  bracketName: string;
+  type: 'string' | 'string[]' | 'string[] | undefined';
+  /**
+   * Ordered list of params.ts files in the route chain that may declare
+   * a codec for this param, in priority order — **closest-to-leaf
+   * first**. The generated type emits a chain that picks the first
+   * entry whose `segmentParams` definition declares this param key.
+   *
+   * This array is the SAME for every param in a given route entry
+   * (it is the route's full ancestry of params.ts files in leaf-first
+   * order); the type-level conditional in `buildCodecChainType`
+   * narrows per-key. Sharing the array matches the runtime semantics
+   * of `coerceSegmentParams`, which walks segments top-down and lets
+   * later (deeper) coercions overwrite earlier ones — closest-to-leaf
+   * wins for both types and runtime.
+   *
+   * See TIM-834.
+   */
+  codecFilePaths?: string[];
+  /**
+   * Per-segment legacy fallback: a layout.tsx or page.tsx that exports
+   * `segmentParams` directly (pre-TIM-508 convention). Used only when
+   * the chain has no params.ts files at all. Does NOT participate in
+   * inheritance — a layout/page export is per-segment only.
+   *
+   * @internal Set during `collectRoutes`; consumed at leaf time when
+   *   building the final `codecFilePaths`.
+   */
+  legacyCodecFilePath?: string;
+}