veryfront 0.1.83 → 0.1.84

package/src/src/proxy/main.ts

@@ -37,12 +37,12 @@ import {
   withSpan,
 } from "./tracing.js";
 import { proxyLogger, runWithProxyRequestContext } from "./logger.js";
-import { ErrorPages } from "../server/utils/error-html.js";
 import { RendererRouter } from "./renderer-router.js";
 import { ServerResolver } from "./server-resolver.js";
 import { parseProjectDomain } from "../server/utils/domain-parser.js";
 import { exit, getEnv, onSignal } from "../platform/compat/process.js";
 import { createHttpServer, upgradeWebSocket } from "../platform/compat/http/index.js";
+import { createProxyErrorResponse, jsonErrorResponse } from "./error-response.js";
 
 function getLocalProjects(): Record<string, string> {
   const raw = getEnv("LOCAL_PROJECTS");
@@ -274,13 +274,6 @@ function handleWebSocketUpgrade(req: dntShim.Request): dntShim.Response {
   return response;
 }
 
-function jsonErrorResponse(status: number, body: Record<string, unknown>): dntShim.Response {
-  return new dntShim.Response(JSON.stringify(body), {
-    status,
-    headers: { "Content-Type": "application/json" },
-  });
-}
-
 function forwardToServer(req: dntShim.Request): Promise<dntShim.Response> {
   const startTime = performance.now();
   const url = new URL(req.url);
@@ -311,25 +304,7 @@ function forwardToServer(req: dntShim.Request): Promise<dntShim.Response> {
             const logLevel = ctx.error.status < 500 ? "warn" : "error";
             proxyLogger[logLevel](`${ctx.error.status} ${req.method} ${url.pathname}`, { ms });
             endSpan(spanInfo?.span, ctx.error.status);
-
-            if (ctx.error.redirectUrl) {
-              return new dntShim.Response(null, {
-                status: 302,
-                headers: { Location: ctx.error.redirectUrl },
-              });
-            }
-
-            if (ctx.error.slug === "release-not-found") {
-              return new dntShim.Response(ErrorPages.notFound(), {
-                status: 404,
-                headers: { "Content-Type": "text/html; charset=utf-8" },
-              });
-            }
-
-            return jsonErrorResponse(ctx.error.status, {
-              error: ctx.error.message,
-              status: ctx.error.status,
-            });
+            return createProxyErrorResponse(ctx.error);
           }
 
           const reqLogger = proxyLogger.child({

package/src/src/transforms/esm/http-cache-helpers.ts

@@ -9,6 +9,8 @@ import { cwd } from "../../platform/compat/process.js";
 import { rendererLogger } from "../../utils/index.js";
 import { resolveImport } from "../../modules/import-map/resolver.js";
 import type { ImportMapConfig } from "../../modules/import-map/types.js";
+import { buildEsmShUrl } from "../import-rewriter/url-builder.js";
+import { parseBarePackageSpecifier } from "../shared/package-specifier.js";
 import { DEFAULT_REACT_VERSION, getReactImportMap } from "./package-registry.js";
 
 const logger = rendererLogger.component("http-cache");
@@ -149,7 +151,16 @@ export function resolveBareSpecifier(
   const mapped = resolveImport(specifier, importMap);
   if (mapped !== specifier) return mapped;
 
-  return `https://esm.sh/${specifier}?target=es2022`;
+  const parsed = parseBarePackageSpecifier(specifier);
+  if (parsed == null) {
+    return `https://esm.sh/${specifier}?target=es2022`;
+  }
+
+  return buildEsmShUrl(
+    parsed.packageName,
+    parsed.version ?? undefined,
+    parsed.subpath ?? undefined,
+  );
 }
 
 /**

package/src/src/transforms/import-rewriter/strategies/bare-strategy.ts

@@ -13,6 +13,7 @@ import type {
   RewriteResult,
 } from "../types.js";
 import { buildEsmShUrl, TAILWIND_VERSION } from "../url-builder.js";
+import { parseBarePackageSpecifier } from "../../shared/package-specifier.js";
 
 const logger = rendererLogger.component("esm");
 
@@ -22,10 +23,6 @@ function hasVersionSpecifier(specifier: string): boolean {
   return /@[\d^~x][\d.x^~-]*(?=\/|$)/.test(specifier);
 }
 
-function normalizeVersionedSpecifier(specifier: string): string {
-  return specifier.replace(/@[\d^~x][\d.x^~-]*(?=\/|$)/, "");
-}
-
 function warnUnversionedImport(specifier: string, projectId: string): void {
   const key = `${projectId}:${specifier}`;
   if (unversionedImportsWarned.has(key)) return;
@@ -73,20 +70,22 @@ export class BareStrategy implements ImportRewriteStrategy {
   rewrite(info: ImportSpecifierInfo, ctx: RewriteContext): RewriteResult {
     if (ctx.target === "ssr") return { specifier: null };
 
-    const normalized = normalizeVersionedSpecifier(info.specifier);
+    const parsed = parseBarePackageSpecifier(info.specifier);
+    if (parsed == null) {
+      return { specifier: null };
+    }
 
-    let finalSpecifier = normalized;
+    const packageName = parsed.packageName;
+    let version = parsed.version ?? undefined;
+    const subpath = parsed.subpath ?? undefined;
 
-    if (normalized === "tailwindcss" || normalized.startsWith("tailwindcss/")) {
-      finalSpecifier = normalized.replace(
-        /^tailwindcss/,
-        `tailwindcss@${TAILWIND_VERSION}`,
-      );
+    if (packageName === "tailwindcss") {
+      version = TAILWIND_VERSION;
     } else if (!hasVersionSpecifier(info.specifier)) {
       warnUnversionedImport(info.specifier, ctx.projectId);
     }
 
-    const url = buildEsmShUrl(finalSpecifier, undefined, undefined, {
+    const url = buildEsmShUrl(packageName, version, subpath, {
       external: ["react"],
     });
 

package/src/src/transforms/shared/package-specifier.ts

@@ -0,0 +1,29 @@
+export interface ParsedBarePackageSpecifier {
+  packageName: string;
+  version: string | null;
+  subpath: string | null;
+}
+
+export function parseBarePackageSpecifier(
+  specifier: string,
+): ParsedBarePackageSpecifier | null {
+  const scopedMatch = specifier.match(/^(@[^/]+\/[^/@]+)(?:@([^/]+))?(\/.*)?$/);
+  if (scopedMatch?.[1]) {
+    return {
+      packageName: scopedMatch[1],
+      version: scopedMatch[2] ?? null,
+      subpath: scopedMatch[3] ?? null,
+    };
+  }
+
+  const unscopedMatch = specifier.match(/^([^/@][^/@]*?)(?:@([^/]+))?(\/.*)?$/);
+  if (unscopedMatch?.[1]) {
+    return {
+      packageName: unscopedMatch[1],
+      version: unscopedMatch[2] ?? null,
+      subpath: unscopedMatch[3] ?? null,
+    };
+  }
+
+  return null;
+}