@timber-js/app 0.2.0-alpha.102 → 0.2.0-alpha.103

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@timber-js/app",
-  "version": "0.2.0-alpha.102",
+  "version": "0.2.0-alpha.103",
   "description": "Vite-native React framework built for Servers and Serverless Platforms — correct HTTP semantics, real status codes, pages that work without JavaScript",
   "keywords": [
     "cloudflare-workers",
@@ -110,11 +110,6 @@
   "publishConfig": {
     "access": "public"
   },
-  "scripts": {
-    "build": "vite build --config vite.lib.config.ts && tsc --emitDeclarationOnly --project tsconfig.json --outDir dist",
-    "typecheck": "tsgo --noEmit",
-    "prepublishOnly": "pnpm run build"
-  },
   "dependencies": {
     "@opentelemetry/api": "^1.9.1",
     "@opentelemetry/context-async-hooks": "^2.6.1",
@@ -158,5 +153,9 @@
   },
   "engines": {
     "node": ">=22.12.0"
+  },
+  "scripts": {
+    "build": "vite build --config vite.lib.config.ts && tsc --emitDeclarationOnly --project tsconfig.json --outDir dist",
+    "typecheck": "tsgo --noEmit"
   }
-}
+}

package/src/fonts/ast.ts

@@ -590,8 +590,8 @@ interface CallExpressionNode extends PositionedNode {
 
 interface VariableDeclaratorNode extends PositionedNode {
   type: 'VariableDeclarator';
-  id: AstNode;
-  init: AstNode | null;
+  id: PositionedNode;
+  init: PositionedNode | null;
 }
 
 interface VariableDeclarationNode extends PositionedNode {
@@ -601,7 +601,43 @@ interface VariableDeclarationNode extends PositionedNode {
 
 interface ExpressionStatementNode extends PositionedNode {
   type: 'ExpressionStatement';
-  expression: AstNode;
+  expression: PositionedNode;
+}
+
+interface ExportNamedDeclarationNode extends PositionedNode {
+  type: 'ExportNamedDeclaration';
+  declaration: VariableDeclarationNode | ExpressionStatementNode | null;
+}
+
+// ── Type guards for AST narrowing ────────────────────────────────────────────
+//
+// OXC's parsed nodes all share the base `PositionedNode` shape with
+// `type: string`. TypeScript can't narrow a union that includes a
+// `string`-typed catch-all, so we use explicit type guards instead of
+// bare `.type ===` checks.
+
+function isImportDeclaration(node: PositionedNode): node is ImportDeclarationNode {
+  return node.type === 'ImportDeclaration';
+}
+
+function isVariableDeclaration(node: PositionedNode): node is VariableDeclarationNode {
+  return node.type === 'VariableDeclaration';
+}
+
+function isExpressionStatement(node: PositionedNode): node is ExpressionStatementNode {
+  return node.type === 'ExpressionStatement';
+}
+
+function isExportNamedDeclaration(node: PositionedNode): node is ExportNamedDeclarationNode {
+  return node.type === 'ExportNamedDeclaration';
+}
+
+function isCallExpression(node: PositionedNode): node is CallExpressionNode {
+  return node.type === 'CallExpression';
+}
+
+function isIdentifier(node: AstNode): node is IdentifierNode {
+  return node.type === 'Identifier';
 }
 
 interface ProgramNode extends PositionedNode {
@@ -627,8 +663,8 @@ export function findFontCallSites(source: string): FontAnalysis | null {
   const importNodesToRemove: Array<{ start: number; end: number }> = [];
 
   for (const stmt of program.body) {
-    if (stmt.type !== 'ImportDeclaration') continue;
-    const importDecl = stmt as unknown as ImportDeclarationNode;
+    if (!isImportDeclaration(stmt)) continue;
+    const importDecl = stmt;
     const specSource = importDecl.source.value;
 
     let provider: 'google' | 'local' | null = null;
@@ -658,7 +694,7 @@ export function findFontCallSites(source: string): FontAnalysis | null {
       // member expressions in the call-site walk.
     }
 
-    importNodesToRemove.push({ start: importDecl.start, end: importDecl.end });
+    importNodesToRemove.push({ start: stmt.start, end: stmt.end });
   }
 
   if (bindings.length === 0) return null;
@@ -669,27 +705,30 @@ export function findFontCallSites(source: string): FontAnalysis | null {
   let dynamicCall: string | null = null;
 
   for (const stmt of program.body) {
+    // Unwrap `export const roboto = Roboto(...)` — the AST wraps the
+    // VariableDeclaration inside an ExportNamedDeclaration node.
+    const effectiveStmt =
+      isExportNamedDeclaration(stmt) && stmt.declaration ? stmt.declaration : stmt;
+
     // VariableDeclaration: `const inter = Inter({ ... })`
-    if (stmt.type === 'VariableDeclaration') {
-      const varDecl = stmt as unknown as VariableDeclarationNode;
-      for (const declarator of varDecl.declarations) {
-        if (!declarator.init || declarator.init.type !== 'CallExpression') continue;
-        const call = declarator.init as unknown as CallExpressionNode;
+    if (isVariableDeclaration(effectiveStmt)) {
+      for (const declarator of effectiveStmt.declarations) {
+        if (!declarator.init) continue;
+        if (!isCallExpression(declarator.init)) continue;
+        const call = declarator.init;
         const site = matchCallExpression(call, bindingsByName, source);
         if (!site) continue;
 
         if (site === 'dynamic') {
-          if (!dynamicCall) {
-            const calleeName = (call.callee as IdentifierNode).name;
+          if (!dynamicCall && isIdentifier(call.callee)) {
             const argStart = call.arguments[0].start;
             const argEnd = call.arguments[0].end;
-            dynamicCall = `${calleeName}(${source.slice(argStart, argEnd)})`;
+            dynamicCall = `${call.callee.name}(${source.slice(argStart, argEnd)})`;
           }
           continue;
         }
 
-        const assignedName =
-          declarator.id.type === 'Identifier' ? (declarator.id as IdentifierNode).name : null;
+        const assignedName = isIdentifier(declarator.id) ? declarator.id.name : null;
 
         const { line, column } = offsetToLineColumn(source, call.start);
         callSites.push({
@@ -705,10 +744,9 @@ export function findFontCallSites(source: string): FontAnalysis | null {
     }
 
     // ExpressionStatement: `Inter({ ... })` as a bare call
-    if (stmt.type === 'ExpressionStatement') {
-      const exprStmt = stmt as unknown as ExpressionStatementNode;
-      if (exprStmt.expression.type === 'CallExpression') {
-        const call = exprStmt.expression as unknown as CallExpressionNode;
+    if (isExpressionStatement(effectiveStmt)) {
+      if (isCallExpression(effectiveStmt.expression)) {
+        const call = effectiveStmt.expression;
         const site = matchCallExpression(call, bindingsByName, source);
         if (site && site !== 'dynamic') {
           const { line, column } = offsetToLineColumn(source, call.start);
@@ -716,16 +754,15 @@ export function findFontCallSites(source: string): FontAnalysis | null {
             binding: site.binding,
             assignedName: null,
             configNode: site.configNode,
-            replaceStart: (exprStmt as PositionedNode).start,
-            replaceEnd: (exprStmt as PositionedNode).end,
+            replaceStart: effectiveStmt.start,
+            replaceEnd: effectiveStmt.end,
             line,
             column,
           });
-        } else if (site === 'dynamic' && !dynamicCall) {
-          const calleeName = (call.callee as IdentifierNode).name;
+        } else if (site === 'dynamic' && !dynamicCall && isIdentifier(call.callee)) {
           const argStart = call.arguments[0].start;
           const argEnd = call.arguments[0].end;
-          dynamicCall = `${calleeName}(${source.slice(argStart, argEnd)})`;
+          dynamicCall = `${call.callee.name}(${source.slice(argStart, argEnd)})`;
         }
       }
     }
@@ -817,8 +854,8 @@ function matchCallExpression(
   bindings: Map<string, FontBinding>,
   _source: string
 ): { binding: FontBinding; configNode: AstNode } | 'dynamic' | null {
-  if (call.callee.type !== 'Identifier') return null;
-  const calleeName = (call.callee as IdentifierNode).name;
+  if (!isIdentifier(call.callee)) return null;
+  const calleeName = call.callee.name;
   const binding = bindings.get(calleeName);
   if (!binding) return null;