rsbuild-plugin-react-router 0.1.1 → 0.3.0

package/src/route-artifacts.ts

@@ -0,0 +1,155 @@
+import {
+  CLIENT_ROUTE_EXPORTS_SET,
+  SERVER_ONLY_ROUTE_EXPORTS_SET,
+} from './constants.js';
+import { getExportNames } from './export-utils.js';
+import {
+  buildEnforceChunkValidity,
+  detectRouteChunksIfEnabled,
+  emptyRouteChunkSnippet,
+  getRouteChunkIfEnabled,
+  getRouteChunkNameFromModuleId,
+  shouldAnalyzeRouteChunks,
+  validateRouteChunks,
+  type RouteChunkCache,
+  type RouteChunkConfig,
+} from './route-chunks.js';
+
+export type RouteClientEntryArtifactOptions = {
+  code: string;
+  resourcePath: string;
+  environmentName?: string;
+  isBuild: boolean;
+  routeChunkCache?: RouteChunkCache;
+  routeChunkConfig: RouteChunkConfig;
+};
+
+type RouteClientEntryArtifact = {
+  code: string;
+};
+
+export type RouteChunkArtifactOptions = {
+  code: string;
+  resource: string;
+  resourcePath: string;
+  isBuild: boolean;
+  routeChunkCache?: RouteChunkCache;
+  routeChunkConfig: RouteChunkConfig;
+};
+
+type RouteChunkArtifact = {
+  code: string;
+  map: null;
+};
+
+export const buildRouteClientEntryCode = ({
+  exportNames,
+  chunkedExports,
+  isServer,
+  resourcePath,
+}: {
+  exportNames: readonly string[];
+  chunkedExports: readonly string[];
+  isServer: boolean;
+  resourcePath: string;
+}): string => {
+  const chunkedExportSet =
+    chunkedExports.length > 0 ? new Set<string>(chunkedExports) : undefined;
+  const reexports = exportNames
+    .filter(exp => {
+      if (chunkedExportSet?.has(exp)) {
+        return false;
+      }
+      return (
+        CLIENT_ROUTE_EXPORTS_SET.has(exp) ||
+        (isServer && SERVER_ONLY_ROUTE_EXPORTS_SET.has(exp))
+      );
+    })
+    .sort();
+  const target = `${resourcePath}?react-router-route`;
+  return `export { ${reexports.join(', ')} } from ${JSON.stringify(target)};`;
+};
+
+export const createRouteClientEntryArtifact = async ({
+  code,
+  resourcePath,
+  environmentName,
+  isBuild,
+  routeChunkCache,
+  routeChunkConfig,
+}: RouteClientEntryArtifactOptions): Promise<RouteClientEntryArtifact> => {
+  const isServer = environmentName === 'node';
+  const mightHaveRouteChunks =
+    !isServer &&
+    isBuild &&
+    shouldAnalyzeRouteChunks(routeChunkConfig, resourcePath, code);
+  const routeChunkInfo = mightHaveRouteChunks
+    ? await detectRouteChunksIfEnabled(
+        routeChunkCache,
+        routeChunkConfig,
+        resourcePath,
+        code
+      )
+    : null;
+  const exportNames =
+    routeChunkInfo?.exportNames ?? (await getExportNames(code));
+  const chunkedExports = routeChunkInfo?.chunkedExports ?? [];
+  return {
+    code: buildRouteClientEntryCode({
+      exportNames,
+      chunkedExports,
+      isServer,
+      resourcePath,
+    }),
+  };
+};
+
+export const createRouteChunkArtifact = async ({
+  code,
+  resource,
+  resourcePath,
+  isBuild,
+  routeChunkCache,
+  routeChunkConfig,
+}: RouteChunkArtifactOptions): Promise<RouteChunkArtifact> => {
+  const splitRouteModules = routeChunkConfig.splitRouteModules;
+  if (!isBuild || !splitRouteModules) {
+    return {
+      code: emptyRouteChunkSnippet(),
+      map: null,
+    };
+  }
+
+  const chunkName = getRouteChunkNameFromModuleId(resource);
+  if (!chunkName) {
+    throw new Error(`Invalid route chunk name in "${resource}"`);
+  }
+  if (chunkName !== 'main' && !code.includes(chunkName)) {
+    return {
+      code: emptyRouteChunkSnippet(),
+      map: null,
+    };
+  }
+
+  const chunk = await getRouteChunkIfEnabled(
+    routeChunkCache,
+    routeChunkConfig,
+    resourcePath,
+    chunkName,
+    code
+  );
+
+  if (splitRouteModules === 'enforce' && chunkName === 'main' && chunk) {
+    const exportNames = await getExportNames(chunk);
+    validateRouteChunks({
+      config: routeChunkConfig,
+      id: resourcePath,
+      valid: buildEnforceChunkValidity(exportNames),
+    });
+  }
+
+  return {
+    code: chunk ?? emptyRouteChunkSnippet(),
+    map: null,
+  };
+};

package/src/route-ast.ts

@@ -0,0 +1,163 @@
+import type { ParseResult } from 'yuku-parser';
+
+export type AnyNode = Record<string, any>;
+
+export type ProgramNode = AnyNode & {
+  body: AnyNode[];
+};
+
+export const getProgram = (ast: ParseResult | AnyNode): ProgramNode =>
+  ((ast as ParseResult).program ?? ast) as ProgramNode;
+
+export const getPatternIdentifierNames = (
+  pattern: AnyNode | null | undefined,
+  names: Set<string> = new Set()
+): Set<string> => {
+  if (!pattern) {
+    return names;
+  }
+  if (pattern.type === 'Identifier') {
+    names.add(pattern.name);
+    return names;
+  }
+  if (pattern.type === 'RestElement') {
+    return getPatternIdentifierNames(pattern.argument, names);
+  }
+  if (pattern.type === 'AssignmentPattern') {
+    return getPatternIdentifierNames(pattern.left, names);
+  }
+  if (pattern.type === 'ArrayPattern') {
+    for (const element of pattern.elements ?? []) {
+      getPatternIdentifierNames(element, names);
+    }
+    return names;
+  }
+  if (pattern.type === 'ObjectPattern') {
+    for (const property of pattern.properties ?? []) {
+      if (property.type === 'RestElement') {
+        getPatternIdentifierNames(property.argument, names);
+      } else {
+        getPatternIdentifierNames(property.value, names);
+      }
+    }
+  }
+  return names;
+};
+
+export const getIdentifierNamesFromPattern = (
+  pattern: AnyNode | null | undefined
+): string[] => Array.from(getPatternIdentifierNames(pattern));
+
+export const patternIncludesName = (
+  pattern: AnyNode | null | undefined,
+  name: string
+): boolean => getPatternIdentifierNames(pattern).has(name);
+
+export const getExportedName = (
+  node: AnyNode | null | undefined
+): string | null => {
+  const exported = node?.exported ?? node;
+  if (!exported) {
+    return null;
+  }
+  if (exported.type === 'Identifier') {
+    return exported.name;
+  }
+  if (exported.type === 'Literal' || exported.type === 'StringLiteral') {
+    return String(exported.value);
+  }
+  return null;
+};
+
+export const identifier = (name: string): AnyNode => ({
+  type: 'Identifier',
+  start: 0,
+  end: 0,
+  name,
+  decorators: [],
+  optional: false,
+  typeAnnotation: null,
+});
+
+export const literal = (value: string): AnyNode => ({
+  type: 'Literal',
+  start: 0,
+  end: 0,
+  value,
+  raw: JSON.stringify(value),
+});
+
+export const callExpression = (callee: AnyNode, args: AnyNode[]): AnyNode => ({
+  type: 'CallExpression',
+  start: 0,
+  end: 0,
+  callee,
+  arguments: args,
+  optional: false,
+});
+
+export const importDeclaration = (
+  specifiers: Array<{ local: string; imported: string }>,
+  source: string
+): AnyNode => ({
+  type: 'ImportDeclaration',
+  start: 0,
+  end: 0,
+  specifiers: specifiers.map(specifier => ({
+    type: 'ImportSpecifier',
+    start: 0,
+    end: 0,
+    imported: identifier(specifier.imported),
+    local: identifier(specifier.local),
+    importKind: 'value',
+  })),
+  source: literal(source),
+  attributes: [],
+  phase: null,
+  importKind: 'value',
+});
+
+export const exportSpecifier = (local: string, exported: string): AnyNode => ({
+  type: 'ExportSpecifier',
+  start: 0,
+  end: 0,
+  local: identifier(local),
+  exported: identifier(exported),
+  exportKind: 'value',
+});
+
+export const exportNamedDeclaration = (specifiers: AnyNode[]): AnyNode => ({
+  type: 'ExportNamedDeclaration',
+  start: 0,
+  end: 0,
+  declaration: null,
+  specifiers,
+  source: null,
+  attributes: [],
+  exportKind: 'value',
+});
+
+export const variableDeclaration = (name: string, init: AnyNode): AnyNode => ({
+  type: 'VariableDeclaration',
+  start: 0,
+  end: 0,
+  kind: 'const',
+  declare: false,
+  declarations: [
+    {
+      type: 'VariableDeclarator',
+      start: 0,
+      end: 0,
+      id: identifier(name),
+      init,
+      definite: false,
+    },
+  ],
+});
+
+export const removeFromArray = <T>(array: T[], value: T): void => {
+  const index = array.indexOf(value);
+  if (index >= 0) {
+    array.splice(index, 1);
+  }
+};