@timber-js/app 0.2.0-alpha.7 → 0.2.0-alpha.71

package/src/plugins/cache-transform.ts

@@ -1,199 +0,0 @@
-import type { Plugin } from 'vite';
-import { findFunctionsWithDirective, containsDirective } from '#/utils/directive-parser.js';
-
-/**
- * Parse a cacheLife duration string to seconds.
- * Supports: '30s', '5m', '1h', '2d', '1w', or a plain number (seconds).
- */
-export function parseCacheLife(value: string | number): number {
-  if (typeof value === 'number') return value;
-
-  const match = value.match(/^(\d+)(s|m|h|d|w)$/);
-  if (!match) {
-    throw new Error(
-      `Invalid cacheLife value: "${value}". Expected format: "30s", "5m", "1h", "2d", "1w", or a number.`
-    );
-  }
-
-  const amount = parseInt(match[1], 10);
-  const unit = match[2];
-  const multipliers: Record<string, number> = { s: 1, m: 60, h: 3600, d: 86400, w: 604800 };
-  return amount * multipliers[unit];
-}
-
-// Default TTL when no cacheLife() is specified (Infinity means cache until explicit invalidation).
-const DEFAULT_TTL = Infinity;
-
-export interface CacheTransformWarning {
-  message: string;
-  functionName: string;
-}
-
-interface TransformResult {
-  code: string;
-  map?: null;
-  warnings?: CacheTransformWarning[];
-}
-
-/**
- * Match cacheLife() calls: cacheLife('1h'), cacheLife("5m"), cacheLife(300)
- */
-const CACHE_LIFE_PATTERN = /cacheLife\(\s*(?:'([^']+)'|"([^"]+)"|(\d+))\s*\)/;
-
-/**
- * Strip the 'use cache' directive and cacheLife() call from a function body.
- * Returns the cleaned body and the extracted TTL.
- */
-function extractCacheDirectives(body: string): { cleanBody: string; ttl: number } {
-  let ttl = DEFAULT_TTL;
-
-  // Remove 'use cache' / "use cache" directive (including optional semicolon and newline)
-  let cleanBody = body.replace(/\s*['"]use cache['"];?\s*\n?/, '\n');
-
-  // Extract and remove cacheLife() calls
-  const lifeMatch = cleanBody.match(CACHE_LIFE_PATTERN);
-  if (lifeMatch) {
-    const value = lifeMatch[1] || lifeMatch[2] || parseInt(lifeMatch[3], 10);
-    ttl = parseCacheLife(value);
-    cleanBody = cleanBody.replace(/\s*cacheLife\([^)]*\);?\s*\n?/, '\n');
-  }
-
-  return { cleanBody, ttl };
-}
-
-/**
- * Determine if a function name is a React component (PascalCase).
- */
-function isComponentName(name: string): boolean {
-  return /^[A-Z]/.test(name);
-}
-
-/**
- * Pattern matching page/layout file conventions in a dynamic route segment.
- * Matches paths like: app/[slug]/page.tsx, app/[id]/layout.ts, etc.
- */
-const DYNAMIC_ROUTE_PAGE_PATTERN = /\/\[[^\]]+\].*\/(page|layout)\.[jt]sx?$/;
-
-/**
- * Detect if a function declaration has Promise-typed parameters.
- *
- * Checks for common patterns:
- * - `params: Promise<...>`
- * - `{ params }: { params: Promise<...> }`
- * - `props: { params: Promise<...> }`
- */
-const PROMISE_PARAMS_PATTERN = /params\s*(?::|.*?:)\s*Promise\s*</;
-
-/**
- * Check if a 'use cache' function in a dynamic route page/layout receives
- * Promise-typed params, which are not serializable as cache keys.
- */
-export function detectPromiseParamsWarning(
-  declaration: string,
-  functionName: string,
-  fileId: string
-): CacheTransformWarning | null {
-  if (!DYNAMIC_ROUTE_PAGE_PATTERN.test(fileId)) return null;
-  if (!PROMISE_PARAMS_PATTERN.test(declaration)) return null;
-
-  return {
-    message:
-      `'use cache' on "${functionName}" in "${fileId}" receives Promise params. ` +
-      `Promise is not serializable as a cache key and will cause runtime errors. ` +
-      `Either remove 'use cache' or await the params before using them in a separate cached function.`,
-    functionName,
-  };
-}
-
-/**
- * Transform source code containing 'use cache' directives into
- * registerCachedFunction() calls.
- *
- * Returns null if no transformations were made.
- */
-export function transformUseCache(code: string, fileId: string): TransformResult | null {
-  if (!containsDirective(code, 'use cache')) return null;
-
-  const functions = findFunctionsWithDirective(code, 'use cache');
-  if (functions.length === 0) return null;
-
-  let result = code;
-  let needsImport = false;
-  const warnings: CacheTransformWarning[] = [];
-
-  // Process functions from end to start (sorted descending by start position)
-  for (const fn of functions) {
-    // Warn if function receives Promise params in a dynamic route page/layout
-    const promiseWarning = detectPromiseParamsWarning(fn.declaration, fn.name, fileId);
-    if (promiseWarning) warnings.push(promiseWarning);
-    const { cleanBody, ttl } = extractCacheDirectives(fn.bodyContent);
-    const stableId = `${fileId}#${fn.name}`;
-    const isComponent = isComponentName(fn.name);
-
-    // Build the options object
-    const optsParts = [`ttl: ${ttl === Infinity ? 'Infinity' : ttl}`];
-    optsParts.push(`id: '${stableId}'`);
-    if (isComponent) {
-      optsParts.push('isComponent: true');
-    }
-    const optsStr = `{ ${optsParts.join(', ')} }`;
-
-    // Build the replacement
-    let replacement: string;
-    if (fn.isArrow) {
-      // const Name = async (...) => { body } → const Name = registerCachedFunction(async (...) => { body }, opts)
-      const arrowSig = fn.declaration.replace(/^(?:const|let|var)\s+\w+\s*=\s*/, '');
-      replacement = `const ${fn.name} = registerCachedFunction(${arrowSig} {${cleanBody}}, ${optsStr})`;
-    } else {
-      // async function Name(...) { body } → const Name = registerCachedFunction(async function Name(...) { body }, opts)
-      const fnDecl = fn.declaration.replace(/^(?:export\s+default\s+|export\s+)?/, '');
-      const exportPrefix = fn.prefix.includes('default')
-        ? 'export default '
-        : fn.prefix.includes('export')
-          ? 'export '
-          : '';
-
-      replacement = `${exportPrefix}const ${fn.name} = registerCachedFunction(${fnDecl} {${cleanBody}}, ${optsStr})`;
-    }
-
-    result = result.slice(0, fn.start) + replacement + result.slice(fn.end);
-    needsImport = true;
-  }
-
-  if (needsImport) {
-    // Add the import at the top of the file
-    result = `import { registerCachedFunction } from '@timber-js/app/cache';\n` + result;
-  }
-
-  return { code: result, map: null, warnings: warnings.length > 0 ? warnings : undefined };
-}
-
-/**
- * Vite plugin: timber-cache
- *
- * Transforms 'use cache' directives into registerCachedFunction() calls.
- * Only runs in the RSC environment.
- */
-export function cacheTransformPlugin(): Plugin {
-  return {
-    name: 'timber-cache',
-
-    transform(code, id) {
-      // Only transform in RSC environment
-      // Skip node_modules and non-JS/TS files
-      if (id.includes('node_modules')) return null;
-      if (!/\.[jt]sx?$/.test(id)) return null;
-
-      // Quick bail-out: no 'use cache' directive in this file
-      if (!containsDirective(code, 'use cache')) return null;
-
-      const result = transformUseCache(code, id);
-      if (result?.warnings) {
-        for (const w of result.warnings) {
-          this.warn(`[timber] ${w.message}`);
-        }
-      }
-      return result;
-    },
-  };
-}

package/src/plugins/dynamic-transform.ts

@@ -1,161 +0,0 @@
-/**
- * timber-dynamic-transform — Vite sub-plugin for 'use dynamic' directive.
- *
- * Detects `'use dynamic'` directives in server component function bodies
- * and transforms them into `markDynamic()` runtime calls. The directive
- * declares a dynamic boundary — the component and its subtree opt out of
- * the pre-rendered shell and render per-request.
- *
- * - In `output: 'static'` mode, `'use dynamic'` is a build error.
- * - In standard SSR routes (no prerender.ts), the directive is a no-op
- *   (everything is already per-request), but the transform still runs
- *   so the runtime can skip unnecessary work.
- *
- * Design doc: design/15-future-prerendering.md §"'use dynamic'"
- */
-
-import type { Plugin } from 'vite';
-import type { PluginContext } from '#/index.js';
-import { findFunctionsWithDirective, containsDirective } from '#/utils/directive-parser.js';
-
-// ---------------------------------------------------------------------------
-// Detection
-// ---------------------------------------------------------------------------
-
-/**
- * Quick check: does this source file contain 'use dynamic' anywhere?
- * Used as a fast bail-out before doing expensive AST parsing.
- */
-export function containsUseDynamic(code: string): boolean {
-  return containsDirective(code, 'use dynamic');
-}
-
-// ---------------------------------------------------------------------------
-// Transform
-// ---------------------------------------------------------------------------
-
-interface TransformResult {
-  code: string;
-  map?: null;
-}
-
-/**
- * Find function declarations/expressions containing 'use dynamic' and
- * transform them into markDynamic() calls.
- *
- * Input:
- * ```tsx
- * export default async function AddToCartButton({ productId }) {
- *   'use dynamic'
- *   const user = await getUser()
- *   return <button>Add to cart</button>
- * }
- * ```
- *
- * Output:
- * ```tsx
- * import { markDynamic as __markDynamic } from '@timber-js/app/runtime';
- * export default async function AddToCartButton({ productId }) {
- *   __markDynamic();
- *   const user = await getUser()
- *   return <button>Add to cart</button>
- * }
- * ```
- *
- * The markDynamic() call registers the component boundary as dynamic
- * at render time. The pre-render pass uses this to know which subtrees
- * to skip and leave as holes for per-request rendering.
- */
-export function transformUseDynamic(code: string): TransformResult | null {
-  if (!containsUseDynamic(code)) return null;
-
-  const functions = findFunctionsWithDirective(code, 'use dynamic');
-  if (functions.length === 0) return null;
-
-  // Replace directive strings with __markDynamic() calls, processing
-  // from end to start to preserve source offsets
-  let result = code;
-  for (const fn of functions) {
-    // Replace the directive in the body content
-    const cleanBody = fn.bodyContent.replace(/['"]use dynamic['"];?/, '__markDynamic();');
-    // Reconstruct: replace the body content between braces
-    result = result.slice(0, fn.bodyStart) + cleanBody + result.slice(fn.bodyEnd);
-  }
-
-  // Add the import at the top
-  result = `import { markDynamic as __markDynamic } from '@timber-js/app/runtime';\n` + result;
-
-  return { code: result, map: null };
-}
-
-// ---------------------------------------------------------------------------
-// Static mode validation
-// ---------------------------------------------------------------------------
-
-/**
- * In `output: 'static'` mode, `'use dynamic'` is a build error.
- * Static mode renders everything at build time — there is no per-request
- * rendering to opt into.
- */
-export function validateNoDynamicInStaticMode(
-  code: string
-): { message: string; line?: number } | null {
-  if (!containsUseDynamic(code)) return null;
-
-  const functions = findFunctionsWithDirective(code, 'use dynamic');
-  if (functions.length === 0) return null;
-
-  return {
-    message:
-      `'use dynamic' cannot be used in static mode (output: 'static'). ` +
-      `Static mode renders all content at build time — there is no per-request rendering. ` +
-      `Remove the directive or switch to output: 'server'.`,
-    line: functions[functions.length - 1].directiveLine, // First occurrence (sorted descending)
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Vite Plugin
-// ---------------------------------------------------------------------------
-
-/**
- * Create the timber-dynamic-transform Vite plugin.
- *
- * In server mode: transforms 'use dynamic' into markDynamic() calls.
- * In static mode: rejects 'use dynamic' as a build error.
- */
-export function timberDynamicTransform(ctx: PluginContext): Plugin {
-  const isStatic = ctx.config.output === 'static';
-
-  return {
-    name: 'timber-dynamic-transform',
-
-    transform(code: string, id: string) {
-      // Skip node_modules
-      if (id.includes('node_modules')) return null;
-
-      // Only check files in the app directory
-      if (!id.includes('/app/') && !id.startsWith('app/')) return null;
-
-      // Only check JS/TS files
-      if (!/\.[jt]sx?$/.test(id)) return null;
-
-      // Quick bail-out
-      if (!containsUseDynamic(code)) return null;
-
-      // In static mode, 'use dynamic' is a build error
-      if (isStatic) {
-        const error = validateNoDynamicInStaticMode(code);
-        if (error) {
-          this.error(
-            `[timber] Static mode error in ${id}${error.line ? `:${error.line}` : ''}: ${error.message}`
-          );
-        }
-        return null;
-      }
-
-      // In server mode, transform the directive
-      return transformUseDynamic(code);
-    },
-  };
-}

package/src/search-params/analyze.ts

@@ -1,192 +0,0 @@
-/**
- * Static analyzability checker for search-params.ts files.
- *
- * Validates that a search-params.ts file's default export is statically
- * analyzable — a createSearchParams() call or a chain of .extend()/.pick()
- * calls on a SearchParamsDefinition.
- *
- * Non-analyzable files produce a hard build error with a diagnostic.
- *
- * Design doc: design/09-typescript.md §"Static Analyzability"
- */
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-/** Result of analyzing a search-params.ts file. */
-export interface AnalyzeResult {
-  /** Whether the file is statically analyzable. */
-  valid: boolean;
-  /** Error details when valid is false. */
-  error?: AnalyzeError;
-}
-
-/** Diagnostic error for non-analyzable search-params.ts. */
-export interface AnalyzeError {
-  /** Absolute file path. */
-  filePath: string;
-  /** Description of the non-analyzable expression. */
-  expression: string;
-  /** Suggested fix. */
-  suggestion: string;
-}
-
-// ---------------------------------------------------------------------------
-// AST-free source analysis
-//
-// We use a lightweight regex-based approach to validate the structure of the
-// default export. This avoids requiring a TypeScript compiler instance at
-// build time for the initial validation pass. The full type extraction
-// (reading T from SearchParamsDefinition<T>) still happens via the TypeScript
-// compiler in the codegen step — this module just validates the *shape*.
-// ---------------------------------------------------------------------------
-
-/**
- * Patterns that indicate a valid default export:
- *
- * 1. `export default createSearchParams(...)`
- * 2. `export default someVar.extend(...)`
- * 3. `export default someVar.pick(...)`
- * 4. `export default someVar.extend(...).extend(...)`  (chained)
- * 5. `export default someVar.extend(...).pick(...)`    (chained)
- * 6. `export default createSearchParams(...).extend(...)`
- *
- * Invalid patterns:
- * - `export default someFunction(...)` (arbitrary factory)
- * - `export default condition ? a : b` (runtime conditional)
- * - `export default variable` (opaque reference without call)
- */
-
-/**
- * Analyze a search-params.ts file source for static analyzability.
- *
- * @param source - The file content as a string
- * @param filePath - Absolute path to the file (for diagnostics)
- */
-export function analyzeSearchParams(source: string, filePath: string): AnalyzeResult {
-  // Strip comments to avoid false matches
-  const stripped = stripComments(source);
-
-  // Find the default export
-  const defaultExport = extractDefaultExport(stripped);
-
-  if (!defaultExport) {
-    return {
-      valid: false,
-      error: {
-        filePath,
-        expression: '(no default export found)',
-        suggestion:
-          'search-params.ts must have a default export. Use: export default createSearchParams({ ... })',
-      },
-    };
-  }
-
-  // Validate the expression
-  if (isValidExpression(defaultExport.trim())) {
-    return { valid: true };
-  }
-
-  return {
-    valid: false,
-    error: {
-      filePath,
-      expression: defaultExport.trim(),
-      suggestion:
-        'The default export must be a createSearchParams() call, or a chain of ' +
-        '.extend() / .pick() calls on a SearchParamsDefinition. Arbitrary factory ' +
-        'functions and runtime conditionals are not supported.',
-    },
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Internal helpers
-// ---------------------------------------------------------------------------
-
-/** Strip single-line and multi-line comments from source. */
-function stripComments(source: string): string {
-  // Remove multi-line comments
-  let result = source.replace(/\/\*[\s\S]*?\*\//g, '');
-  // Remove single-line comments
-  result = result.replace(/\/\/.*$/gm, '');
-  return result;
-}
-
-/**
- * Extract the expression from `export default <expr>`.
- *
- * Handles both:
- *   export default createSearchParams(...)
- *   export default expr\n (terminated by newline or semicolon before next statement)
- */
-function extractDefaultExport(source: string): string | undefined {
-  // Match `export default` followed by the expression
-  const match = source.match(
-    /export\s+default\s+([\s\S]+?)(?:;|\n(?=export|import|const|let|var|function|class|type|interface|declare))/
-  );
-  if (match) {
-    return match[1];
-  }
-
-  // Fallback: match everything after `export default` to end of file
-  const fallback = source.match(/export\s+default\s+([\s\S]+)$/);
-  if (fallback) {
-    return fallback[1].replace(/;\s*$/, '');
-  }
-
-  return undefined;
-}
-
-/**
- * Check if an expression is a valid statically-analyzable pattern.
- *
- * Valid patterns:
- * - Starts with `createSearchParams(`
- * - Contains `.extend(` or `.pick(` chains (possibly starting with createSearchParams or a variable)
- * - A variable identifier followed by chaining
- */
-function isValidExpression(expr: string): boolean {
-  // Normalize whitespace
-  const normalized = expr.replace(/\s+/g, ' ').trim();
-
-  // Pattern 1: starts with createSearchParams(
-  if (normalized.startsWith('createSearchParams(')) {
-    return true;
-  }
-
-  // Pattern 2: chain ending with .extend(...) or .pick(...)
-  // This covers: someVar.extend(...), createSearchParams(...).extend(...).pick(...), etc.
-  if (/\.(extend|pick)\s*\(/.test(normalized)) {
-    // Reject ternaries and other conditional patterns
-    if (/\?/.test(normalized) && /:/.test(normalized)) {
-      return false;
-    }
-    // Reject function declarations/expressions
-    if (/^\s*(function|=>|\()/.test(normalized)) {
-      return false;
-    }
-    return true;
-  }
-
-  return false;
-}
-
-/**
- * Format an AnalyzeError into a human-readable build error message.
- */
-export function formatAnalyzeError(error: AnalyzeError): string {
-  return [
-    `[timber] Non-analyzable search-params.ts`,
-    ``,
-    `  File: ${error.filePath}`,
-    `  Expression: ${error.expression}`,
-    ``,
-    `  ${error.suggestion}`,
-    ``,
-    `  The framework must be able to statically extract the type from your`,
-    `  search-params.ts at build time. Dynamic values, conditionals, and`,
-    `  arbitrary factory functions prevent this analysis.`,
-  ].join('\n');
-}