@reckona/mreact-router 0.0.65 → 0.0.67

package/src/route-path.ts

@@ -0,0 +1,5 @@
+export function normalizeRoutePath(pathname: string): string {
+  const withoutTrailing = pathname.length > 1 ? pathname.replace(/\/+$/, "") : pathname;
+
+  return withoutTrailing === "" ? "/" : withoutTrailing;
+}

package/src/route-shells.ts

@@ -0,0 +1,47 @@
+import { dirname, join, relative } from "node:path";
+
+export type RouteShellKind = "layout" | "template";
+
+export interface RouteShellCandidate {
+  directory: string;
+  file: string;
+  kind: RouteShellKind;
+}
+
+const routeShellFiles = [
+  ["layout.tsx", "layout"],
+  ["layout.mreact.tsx", "layout"],
+  ["template.tsx", "template"],
+  ["template.mreact.tsx", "template"],
+] as const satisfies readonly (readonly [string, RouteShellKind])[];
+
+export function routeShellCandidates(rootDir: string, pageFile: string): RouteShellCandidate[] {
+  const relativeDir = relative(rootDir, dirname(pageFile));
+  const parts = relativeDir === "" ? [] : relativeDir.split(/[\\/]/);
+  const directories = [rootDir];
+
+  for (let index = 0; index < parts.length; index += 1) {
+    directories.push(join(rootDir, ...parts.slice(0, index + 1)));
+  }
+
+  return directories.flatMap((directory) =>
+    routeShellFiles.map(([filename, kind]) => ({
+      directory,
+      file: join(directory, filename),
+      kind,
+    }))
+  );
+}
+
+export async function existingRouteShellCandidates(
+  rootDir: string,
+  pageFile: string,
+  exists: (file: string) => Promise<boolean>,
+): Promise<RouteShellCandidate[]> {
+  const candidates = routeShellCandidates(rootDir, pageFile);
+  const existing = await Promise.all(candidates.map(async (candidate) =>
+    await exists(candidate.file) ? candidate : undefined
+  ));
+
+  return existing.filter((candidate): candidate is RouteShellCandidate => candidate !== undefined);
+}

package/src/route-source.ts

@@ -0,0 +1,224 @@
+import { dirname, isAbsolute, join } from "node:path";
+import {
+  collectTopLevelValueExportNames,
+  collectJsxComponentRootNames,
+  collectStaticImportReferences,
+  demoteTopLevelExportDeclarations,
+  hasModuleDirective,
+  hasTopLevelExportDeclaration,
+  stripTopLevelExportDeclarations,
+} from "@reckona/mreact-compiler";
+import type { StaticImportReference } from "@reckona/mreact-compiler";
+import { sourceModuleCandidates } from "./source-modules.js";
+
+const routeModuleExportNames = [
+  "auth",
+  "generateStaticParams",
+  "loader",
+  "middleware",
+  "prerender",
+  "revalidate",
+  "stream",
+] as const;
+const routeClientOnlyExportNames = [
+  ...routeModuleExportNames,
+  "generateMetadata",
+  "metadata",
+] as const;
+const routeRequestRenderExportNames = ["default", "slots"] as const;
+const routeRenderExportNames = new Set<string>(["default", "slots"]);
+const routeRequestExportNames = new Set<string>([
+  ...routeClientOnlyExportNames,
+  "generateMetadata",
+  "metadata",
+]);
+const routeLoaderOnlyExportNames = new Set<string>(["loader"]);
+const routeMetadataOnlyExportNames = new Set<string>(["generateMetadata", "metadata"]);
+
+export function stripRouteModuleExports(code: string): string {
+  return demoteRouteHelperExports(stripTopLevelExportDeclarations({
+    code,
+    names: routeModuleExportNames,
+  }));
+}
+
+export function stripRouteClientOnlyExports(code: string): string {
+  return demoteRouteHelperExports(stripTopLevelExportDeclarations({
+    code,
+    names: routeClientOnlyExportNames,
+  }));
+}
+
+export function stripRouteBuildExports(code: string): string {
+  return stripRouteClientOnlyExports(code);
+}
+
+export function stripRouteRequestOnlyExports(code: string): string {
+  return demoteRouteHelperExports(
+    stripTopLevelExportDeclarations({
+      code,
+      names: routeRequestRenderExportNames,
+    }),
+    routeRequestExportNames,
+  );
+}
+
+export function stripRouteLoaderOnlyExports(code: string): string {
+  return demoteRouteHelperExports(
+    stripTopLevelExportDeclarations({
+      code,
+      names: ["auth", "default", "generateMetadata", "generateStaticParams", "metadata", "middleware", "prerender", "revalidate", "slots", "stream"],
+    }),
+    routeLoaderOnlyExportNames,
+  );
+}
+
+export function stripRouteMetadataOnlyExports(code: string): string {
+  return demoteRouteHelperExports(
+    stripTopLevelExportDeclarations({
+      code,
+      names: ["auth", "default", "generateStaticParams", "loader", "middleware", "prerender", "revalidate", "slots", "stream"],
+    }),
+    routeMetadataOnlyExportNames,
+  );
+}
+
+export function stripRouteConfigExports(code: string): string {
+  return stripTopLevelExportDeclarations({
+    code,
+    names: ["auth", "prerender", "revalidate", "stream"],
+  });
+}
+
+export function isStreamRouteSource(code: string): boolean {
+  return hasTopLevelExportDeclaration({ code, names: ["stream"] });
+}
+
+export function mayUseAwaitBoundarySource(code: string): boolean {
+  return collectJsxComponentRootNames({ code }).includes("Await");
+}
+
+export function routeClosureMayUseAwaitBoundary(options: {
+  filename: string;
+  files: Record<string, string>;
+  projectRoot: string;
+  seen?: Set<string> | undefined;
+  source: string;
+}): boolean {
+  const seen = options.seen ?? new Set<string>();
+  if (
+    seen.has(options.filename) ||
+    hasModuleDirective({ code: options.source, directive: "use client" })
+  ) {
+    return false;
+  }
+
+  seen.add(options.filename);
+
+  try {
+    if (mayUseAwaitBoundarySource(options.source)) {
+      return true;
+    }
+
+    const sourceFilename = sourceFilenameForCompiler(options.projectRoot, options.filename);
+    const jsxComponentRoots = new Set(
+      collectJsxComponentRootNames({
+        code: options.source,
+        filename: sourceFilename,
+      }),
+    );
+
+    for (const reference of collectStaticImportReferences({
+      code: options.source,
+      filename: sourceFilename,
+    })) {
+      if (!isRenderedStaticImportReference(reference, jsxComponentRoots)) {
+        continue;
+      }
+
+      const resolved = resolveLocalSourceImport(options.files, options.filename, reference.source);
+
+      if (resolved === undefined) {
+        continue;
+      }
+
+      const importedSource = options.files[resolved];
+
+      if (
+        importedSource !== undefined &&
+        routeClosureMayUseAwaitBoundary({
+          filename: resolved,
+          files: options.files,
+          projectRoot: options.projectRoot,
+          seen,
+          source: importedSource,
+        })
+      ) {
+        return true;
+      }
+    }
+
+    return false;
+  } finally {
+    seen.delete(options.filename);
+  }
+}
+
+export function hasPrerenderExport(code: string): boolean {
+  return hasTopLevelExportDeclaration({ code, names: ["prerender"] });
+}
+
+export function hasGenerateStaticParamsExport(code: string): boolean {
+  return hasTopLevelExportDeclaration({ code, names: ["generateStaticParams"] });
+}
+
+export function hasLoaderExport(code: string): boolean {
+  return hasTopLevelExportDeclaration({ code, names: ["loader"] });
+}
+
+function demoteRouteHelperExports(
+  code: string,
+  preservedExportNames: ReadonlySet<string> = routeRenderExportNames,
+): string {
+  const helperNames = collectTopLevelValueExportNames({ code })
+    .filter((name) => !preservedExportNames.has(name) && startsLowercase(name));
+
+  return helperNames.length === 0
+    ? code
+    : demoteTopLevelExportDeclarations({ code, names: helperNames });
+}
+
+function startsLowercase(value: string): boolean {
+  return /^[a-z]/.test(value);
+}
+
+function isRenderedStaticImportReference(
+  reference: StaticImportReference,
+  jsxComponentRoots: ReadonlySet<string>,
+): boolean {
+  return reference.localNames.some((localName) => jsxComponentRoots.has(localName));
+}
+
+function resolveLocalSourceImport(
+  files: Record<string, string>,
+  importer: string,
+  specifier: string,
+): string | undefined {
+  if (!specifier.startsWith(".")) {
+    return undefined;
+  }
+
+  const base = join(dirname(importer), specifier);
+
+  for (const candidate of sourceModuleCandidates(base)) {
+    if (files[candidate] !== undefined) {
+      return candidate;
+    }
+  }
+
+  return undefined;
+}
+
+function sourceFilenameForCompiler(projectRoot: string, filename: string): string {
+  return isAbsolute(filename) ? filename : join(projectRoot, filename);
+}

package/src/route-styles.ts

@@ -0,0 +1,91 @@
+import { access, readFile } from "node:fs/promises";
+import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
+import { collectStaticImportReferences } from "@reckona/mreact-compiler";
+import { existingRouteShellCandidates } from "./route-shells.js";
+
+export async function collectRouteCssFiles(options: {
+  appDir: string;
+  pageFile: string;
+  projectRoot: string;
+}): Promise<string[]> {
+  const shellFiles = (await existingRouteShellCandidates(options.appDir, options.pageFile, isFile))
+    .map((candidate) => candidate.file);
+  const files = [...shellFiles, options.pageFile];
+  const seen = new Set<string>();
+  const cssFiles: string[] = [];
+
+  for (const file of files) {
+    const source = await readFile(file, "utf8");
+
+    for (const reference of collectStaticImportReferences({ code: source, filename: file })) {
+      const cssFile = resolveCssImport({
+        importer: file,
+        projectRoot: options.projectRoot,
+        source: reference.source,
+      });
+
+      if (cssFile === undefined || seen.has(cssFile)) {
+        continue;
+      }
+
+      seen.add(cssFile);
+      cssFiles.push(cssFile);
+    }
+  }
+
+  return cssFiles;
+}
+
+export async function collectRouteCssHrefs(options: {
+  appDir: string;
+  hrefPrefix?: string | undefined;
+  pageFile: string;
+  projectRoot: string;
+}): Promise<string[]> {
+  return (await collectRouteCssFiles(options)).map((file) => {
+    const href = `/${relative(options.projectRoot, file).split(sep).join("/")}`;
+
+    return options.hrefPrefix === undefined ? href : `${options.hrefPrefix}${href.slice(1)}`;
+  });
+}
+
+function resolveCssImport(options: {
+  importer: string;
+  projectRoot: string;
+  source: string;
+}): string | undefined {
+  if (!isCssSource(options.source)) {
+    return undefined;
+  }
+
+  const resolved = isAbsolute(options.source)
+    ? normalizeInsideProject(options.projectRoot, options.source)
+    : options.source.startsWith(".")
+      ? normalizeInsideProject(options.projectRoot, resolve(dirname(options.importer), options.source))
+      : undefined;
+
+  return resolved;
+}
+
+function normalizeInsideProject(projectRoot: string, file: string): string | undefined {
+  const normalized = resolve(file);
+  const root = resolve(projectRoot);
+  const relativePath = relative(root, normalized);
+
+  return relativePath === "" || relativePath.startsWith("..") || isAbsolute(relativePath)
+    ? undefined
+    : normalized;
+}
+
+function isCssSource(source: string): boolean {
+  return /\.(?:css|pcss|postcss|scss|sass|less|styl|stylus)$/u.test(source);
+}
+
+async function isFile(path: string): Promise<boolean> {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}