veryfront 0.1.82 → 0.1.84

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;
+}

package/src/src/types/entities/getEntityInfo.ts

@@ -43,49 +43,55 @@ export async function getEntityInfo(
       }
 
       try {
+        const shouldReadDirectly = adapter
+          ? isExtendedFSAdapter(adapter.fs) && adapter.fs.isVeryfrontAdapter()
+          : false;
+
+        let content: string;
         if (adapter) {
-          try {
-            const stat = await withFallback(
-              () => adapter.fs.stat(normalizedPath),
-              async () => {
-                const exists = await fs.exists(filePath);
-                if (!exists) {
-                  throw toError(
-                    createError({
-                      type: "file",
-                      message: "File not found",
-                      context: { path: filePath, operation: "read" },
-                    }),
-                  );
-                }
-                return await fs.stat(filePath);
-              },
-              { operationName: "stat:getEntityInfo", logError: false },
-            );
+          if (!shouldReadDirectly) {
+            try {
+              const stat = await withFallback(
+                () => adapter.fs.stat(normalizedPath),
+                async () => {
+                  const exists = await fs.exists(filePath);
+                  if (!exists) {
+                    throw toError(
+                      createError({
+                        type: "file",
+                        message: "File not found",
+                        context: { path: filePath, operation: "read" },
+                      }),
+                    );
+                  }
+                  return await fs.stat(filePath);
+                },
+                { operationName: "stat:getEntityInfo", logError: false },
+              );
 
-            if (!stat.isFile) return null;
-          } catch (error) {
-            entityInfoScope.runSync(
-              () => {
-                throw error;
-              },
-              { path: filePath, details: { reason: "stat-failed" } },
-              undefined,
-            );
-            return null;
+              if (!stat.isFile) return null;
+            } catch (error) {
+              entityInfoScope.runSync(
+                () => {
+                  throw error;
+                },
+                { path: filePath, details: { reason: "stat-failed" } },
+                undefined,
+              );
+              return null;
+            }
           }
-        } else {
-          const exists = await fs.exists(filePath);
-          if (!exists) return null;
-        }
 
-        const content = adapter
-          ? await withFallback(
+          content = await withFallback(
             () => adapter.fs.readFile(normalizedPath),
             () => fs.readTextFile(filePath),
             { operationName: "readFile:getEntityInfo", logError: false },
-          )
-          : await fs.readTextFile(filePath);
+          );
+        } else {
+          const exists = await fs.exists(filePath);
+          if (!exists) return null;
+          content = await fs.readTextFile(filePath);
+        }
 
         const ext = pathHelper.extname(filePath).toLowerCase();
 
@@ -171,26 +177,30 @@ export async function getEntityBySlug(
   return await withSpan(
     "types.getEntityBySlug",
     async () => {
-      const isVeryfrontRoute = slug.startsWith(".veryfront/") || slug === ".veryfront";
+      const normalizedSlug = normalizeSlug(slug);
+      const isVeryfrontRoute = normalizedSlug.startsWith(".veryfront/") ||
+        normalizedSlug === ".veryfront";
       const resolveFile = adapter?.fs.resolveFile;
 
       logger.debug("START", {
         slug,
+        normalizedSlug,
         projectDir,
         isVeryfrontRoute,
         hasResolveFile: !!resolveFile,
       });
 
       if (resolveFile) {
-        const basePaths = [pathHelper.join(projectDir, "pages", slug)];
+        const basePaths = [pathHelper.join(projectDir, "pages", normalizedSlug)];
 
-        if (isVeryfrontRoute) basePaths.unshift(pathHelper.join(projectDir, slug));
-        if (slug === "index" || slug === "") {
+        if (isVeryfrontRoute) basePaths.unshift(pathHelper.join(projectDir, normalizedSlug));
+        if (normalizedSlug === "index" || normalizedSlug === "") {
           basePaths.unshift(pathHelper.join(projectDir, "pages", "index"));
         }
 
         logger.debug("Checking paths (resolveFile branch)", {
           slug,
+          normalizedSlug,
           basePaths,
         });
 
@@ -208,13 +218,14 @@ export async function getEntityBySlug(
           if (info?.entity.isPage) {
             logger.debug("Found page via resolveFile", {
               slug,
+              normalizedSlug,
               path: info.entity.path,
             });
             return info;
           }
         }
 
-        const slugParts = slug.split("/");
+        const slugParts = normalizedSlug === "" ? [] : normalizedSlug.split("/");
         for (let depth = slugParts.length - 1; depth >= 0; depth--) {
           const parentPath = slugParts.slice(0, depth).join("/");
           const pagesDir = parentPath
@@ -259,33 +270,33 @@ export async function getEntityBySlug(
           }
         }
 
-        logger.debug("No page found via resolveFile branch", { slug });
+        logger.debug("No page found via resolveFile branch", { slug, normalizedSlug });
         return null;
       }
 
       const possiblePaths = [
-        pathHelper.join(projectDir, "pages", `${slug}.mdx`),
-        pathHelper.join(projectDir, "pages", `${slug}.md`),
-        pathHelper.join(projectDir, "pages", `${slug}.tsx`),
-        pathHelper.join(projectDir, "pages", `${slug}.jsx`),
-        pathHelper.join(projectDir, "pages", `${slug}.ts`),
-        pathHelper.join(projectDir, "pages", `${slug}/index.mdx`),
-        pathHelper.join(projectDir, "pages", `${slug}/index.md`),
-        pathHelper.join(projectDir, "pages", `${slug}/index.tsx`),
-        pathHelper.join(projectDir, "pages", `${slug}/index.jsx`),
-        pathHelper.join(projectDir, "pages", `${slug}/index.ts`),
+        pathHelper.join(projectDir, "pages", `${normalizedSlug}.mdx`),
+        pathHelper.join(projectDir, "pages", `${normalizedSlug}.md`),
+        pathHelper.join(projectDir, "pages", `${normalizedSlug}.tsx`),
+        pathHelper.join(projectDir, "pages", `${normalizedSlug}.jsx`),
+        pathHelper.join(projectDir, "pages", `${normalizedSlug}.ts`),
+        pathHelper.join(projectDir, "pages", `${normalizedSlug}/index.mdx`),
+        pathHelper.join(projectDir, "pages", `${normalizedSlug}/index.md`),
+        pathHelper.join(projectDir, "pages", `${normalizedSlug}/index.tsx`),
+        pathHelper.join(projectDir, "pages", `${normalizedSlug}/index.jsx`),
+        pathHelper.join(projectDir, "pages", `${normalizedSlug}/index.ts`),
       ];
 
       if (isVeryfrontRoute) {
         possiblePaths.unshift(
-          pathHelper.join(projectDir, `${slug}.mdx`),
-          pathHelper.join(projectDir, `${slug}.md`),
-          pathHelper.join(projectDir, `${slug}.tsx`),
-          pathHelper.join(projectDir, `${slug}.ts`),
+          pathHelper.join(projectDir, `${normalizedSlug}.mdx`),
+          pathHelper.join(projectDir, `${normalizedSlug}.md`),
+          pathHelper.join(projectDir, `${normalizedSlug}.tsx`),
+          pathHelper.join(projectDir, `${normalizedSlug}.ts`),
         );
       }
 
-      if (slug === "index" || slug === "") {
+      if (normalizedSlug === "index" || normalizedSlug === "") {
         possiblePaths.unshift(
           pathHelper.join(projectDir, "pages", "index.mdx"),
           pathHelper.join(projectDir, "pages", "index.md"),
@@ -302,7 +313,7 @@ export async function getEntityBySlug(
         if (info?.entity.isPage) return info;
       }
 
-      const slugParts = slug.split("/");
+      const slugParts = normalizedSlug === "" ? [] : normalizedSlug.split("/");
       for (let depth = slugParts.length - 1; depth >= 0; depth--) {
         const parentPath = slugParts.slice(0, depth).join("/");
         const pagesDir = parentPath
@@ -356,7 +367,11 @@ export async function getEntityBySlug(
 
       return null;
     },
-    { "entity.slug": slug, "entity.projectDir": projectDir },
+    {
+      "entity.slug": slug,
+      "entity.normalized_slug": normalizeSlug(slug),
+      "entity.projectDir": projectDir,
+    },
   );
 }
 
@@ -448,3 +463,7 @@ function getSlugFromPath(filePath: string): string {
   const parentDir = parts[parts.length - 2];
   return parentDir === "pages" ? "" : parentDir ?? "";
 }
+
+function normalizeSlug(slug: string): string {
+  return slug === "/" ? "" : slug.replace(/^\/+/, "").replace(/\/+$/, "");
+}