feat: add conditional rsc mode support (#21)

* feat: add conditional `rsc` mode support

* chore: add changeset

* refactor(compiler): restructure plugins dir

Author: maxprilutskiy

.changeset/seven-poems-retire.md

@@ -0,0 +1,5 @@
+---
+"@replexica/compiler": minor
+---
+
+The compiler now supports the rsc flag, which is set to true by default. When set to false, every piece of code is processed as if it had 'use client'.

packages/compiler/package.json

@@ -26,7 +26,8 @@
     "object-hash": "^3.0.0",
     "typescript": "^5.4.3",
     "unplugin": "^1.10.0",
-    "vitest": "^1.4.0"
+    "vitest": "^1.4.0",
+    "zod": "^3.22.4"
   },
   "devDependencies": {
     "@types/babel__core": "^7.20.5",

packages/compiler/src/compiler/compiler.ts

@@ -8,9 +8,9 @@ import { ReplexicaFileData, ReplexicaCompilerData } from "./types";
 import { ReplexicaScopeExtractor } from "./scope";
 
 export class ReplexicaCompiler {
-  public static fromCode(code: string, relativeFilePath: string) {
+  public static fromCode(code: string, relativeFilePath: string, rsc: boolean) {
     const ast = parseCodeIntoBabelAst(code);
-    const isServer = !hasDirective(ast, 'use client');
+    const isServer = !rsc ? false : !hasDirective(ast, 'use client');
 
     return new ReplexicaCompiler(relativeFilePath, code, ast, isServer);
   }

packages/compiler/src/index.ts

@@ -1,55 +1,5 @@
-import { createUnplugin } from "unplugin"
-import { ReplexicaAttributeScope, ReplexicaCompiler, ReplexicaContentScope, ReplexicaSkipScope } from "./compiler";
-import { ReplexicaOutputProcessor } from "./output";
-import path from 'path';
-import { createNextPlugin } from "./plugins";
-import { ReplexicaConfig } from "./types";
+import { nextPlugin } from "./plugins/next";
 
-const unplugin = createUnplugin<ReplexicaConfig>((options) => ({
-  name: '@replexica/compiler',
-  enforce: 'pre',
-  transformInclude(id) {
-    // .tsx and .jsx files
-    return /\.(t|j)sx$/.test(id);
-  },
-  transform(code, absoluteFilePath) {
-    try {
-      const relativeFilePath = path.relative(process.cwd(), absoluteFilePath);
-
-      const compiler = ReplexicaCompiler
-        .fromCode(code, relativeFilePath)
-        .withScope(ReplexicaSkipScope)
-        .withScope(ReplexicaAttributeScope)
-        .withScope(ReplexicaContentScope)
-        .injectIntl();
-  
-      const result = compiler.generate();
-  
-      const outputProcessor = ReplexicaOutputProcessor.create(relativeFilePath, options);
-      outputProcessor.saveBuildData(compiler.data);
-      outputProcessor.saveFullSourceLocaleData(compiler.data);
-      outputProcessor.saveClientSourceLocaleData(compiler.data);
-      outputProcessor.saveStubLocaleData();
-  
-      if (options.debug) {
-        outputProcessor.saveAst(compiler.ast);
-        outputProcessor.saveOutput(result.code);
-      }
-  
-      return {
-        code: result.code,
-        map: result.map,
-      };
-    } catch (error: any) {
-      throw new ReplexicaError(error.message);
-    }
-  },
-}));
-
-class ReplexicaError extends Error {
-
-}
-export * from './types';
 export default {
-  next: createNextPlugin(unplugin),
+  next: nextPlugin,
 };

packages/compiler/src/options.ts

@@ -0,0 +1,17 @@
+import Z from 'zod';
+
+const supportedLocale = Z.enum(['en', 'es']);
+const optionsSchema = Z.object({
+  locale: Z.object({
+    source: supportedLocale,
+    targets: Z.array(supportedLocale),
+  }),
+  rsc: Z.boolean().optional().default(true),
+  debug: Z.boolean().optional().default(false),
+});
+
+export type ReplexicaConfig = Z.infer<typeof optionsSchema>;
+
+export function parseOptions(options: unknown): ReplexicaConfig {
+  return optionsSchema.parse(options);
+}

packages/compiler/src/output.ts

@@ -1,8 +1,9 @@
 import { File } from "@babel/types";
 import fs from 'fs';
 import path from 'path';
-import { ReplexicaCompilerData, ReplexicaCompilerPayload } from "./compiler";
-import { ReplexicaLocaleData, ReplexicaConfig, ReplexicaData } from "./types";
+import { ReplexicaCompilerData } from "./compiler";
+import { ReplexicaLocaleData, ReplexicaData } from "./types";
+import { ReplexicaConfig } from "./options";
 
 export class ReplexicaOutputProcessor {
   public static create(relativeFilePath: string, options: ReplexicaConfig) {

packages/compiler/src/plugins.ts

@@ -0,0 +1,51 @@
+import { createUnplugin } from "unplugin"
+import { ReplexicaAttributeScope, ReplexicaCompiler, ReplexicaContentScope, ReplexicaSkipScope } from "./../compiler";
+import { ReplexicaOutputProcessor } from "./../output";
+import path from 'path';
+import { ReplexicaConfig, parseOptions } from "../options";
+
+export const basePlugin = createUnplugin<Partial<ReplexicaConfig>>((_options) => ({
+  name: '@replexica/compiler',
+  enforce: 'pre',
+  transformInclude(id) {
+    // .tsx and .jsx files
+    return /\.(t|j)sx$/.test(id);
+  },
+  transform(code, absoluteFilePath) {
+    const options = parseOptions(_options);
+    try {
+      const relativeFilePath = path.relative(process.cwd(), absoluteFilePath);
+
+      const compiler = ReplexicaCompiler
+        .fromCode(code, relativeFilePath, options.rsc)
+        .withScope(ReplexicaSkipScope)
+        .withScope(ReplexicaAttributeScope)
+        .withScope(ReplexicaContentScope)
+        .injectIntl();
+  
+      const result = compiler.generate();
+  
+      const outputProcessor = ReplexicaOutputProcessor.create(relativeFilePath, options);
+      outputProcessor.saveBuildData(compiler.data);
+      outputProcessor.saveFullSourceLocaleData(compiler.data);
+      outputProcessor.saveClientSourceLocaleData(compiler.data);
+      outputProcessor.saveStubLocaleData();
+  
+      if (options.debug) {
+        outputProcessor.saveAst(compiler.ast);
+        outputProcessor.saveOutput(result.code);
+      }
+  
+      return {
+        code: result.code,
+        map: result.map,
+      };
+    } catch (error: any) {
+      throw new ReplexicaError(error.message);
+    }
+  },
+}));
+
+class ReplexicaError extends Error {
+
+}

packages/compiler/src/plugins/base.ts

@@ -0,0 +1,17 @@
+import { basePlugin } from './base';
+import { ReplexicaConfig } from '../options';
+
+export function nextPlugin<O extends ReplexicaConfig>(replexicaOptions: O, nextConfig: any) {
+  return {
+    ...nextConfig,
+    webpack(config: any, options: any) {
+      config.plugins.unshift(basePlugin.webpack(replexicaOptions));
+
+      if (typeof nextConfig.webpack === 'function') {
+        return nextConfig.webpack(config, options);
+      }
+
+      return config;
+    },
+  };
+}

packages/compiler/src/plugins/next.ts

@@ -1,13 +1,5 @@
 import { ReplexicaScopeHint } from "./compiler";
 
-export type ReplexicaConfig = {
-  locale: {
-    source: string;
-    targets: string[];
-  };
-  debug?: boolean;
-};
-
 export type ReplexicaLocaleData = {
   [fileId: string]: {
     [scopeId: string]: {