feat(compiler): add ReplexicaCompiler

Author: maxprilutskiy

packages/compiler/src/compiler/compiler.ts

@@ -0,0 +1,75 @@
+import * as t from "@babel/types";
+import { traverse } from '@babel/core';
+import { generateCodeFromBabelAst, parseCodeIntoBabelAst } from "../utils/babel";
+import { generateFileId } from "../utils/id";
+import { GeneratorResult } from "@babel/generator";
+import { hasDirective } from "../utils/ast";
+import { ReplexicaFileData, ReplexicaCompilerData } from "./types";
+import { ReplexicaScopeExtractor } from "./scope";
+
+export class ReplexicaCompiler {
+  public static fromCode(code: string, relativeFilePath: string, i18nImportPrefix: string) {
+    const ast = parseCodeIntoBabelAst(code);
+    const isServer = !hasDirective(ast, 'use client');
+
+    return new ReplexicaCompiler(relativeFilePath, code, ast, isServer, i18nImportPrefix);
+  }
+
+  private constructor(
+    public readonly relativeFilePath: string,
+    private readonly code: string,
+    public readonly ast: t.File,
+    private readonly isServer: boolean,
+    private readonly i18nImportPrefix: string,
+  ) {
+    this.fileId = generateFileId(relativeFilePath, 0);
+  }
+
+  private readonly fileId: string;
+
+  private _extractors: Set<ReplexicaScopeExtractor> = new Set();
+  private _data: ReplexicaFileData = {};
+
+  public withScope(extractor: ReplexicaScopeExtractor): this {
+    this._extractors.add(extractor);
+    return this;
+  }
+
+  public injectIntl(): this {
+    const _compiler = this;
+    traverse(this.ast, {
+      enter(path) {
+        try {
+          for (const extractor of _compiler._extractors) {
+            const scopes = extractor.fromNode(path);
+            for (const scope of scopes) {
+              const hints = scope.extractHints();
+              const data = scope.injectIntl(_compiler.fileId, _compiler.isServer, _compiler.i18nImportPrefix);
+              _compiler._data[scope.id] = { hints, data };
+            }
+          }
+        } catch (thrownObject) {
+          if (thrownObject === 'skip') {
+            path.skip();
+          } else {
+            throw thrownObject;
+          }
+        }
+      }
+    });
+    return this;
+  }
+
+  public get data(): ReplexicaCompilerData {
+    return {
+      [this.fileId]: {
+        context: { isClient: !this.isServer },
+        data: this._data,
+      },
+    };
+  }
+
+  public generate(): GeneratorResult {
+    return generateCodeFromBabelAst(this.code, this.ast);
+  }
+}

packages/compiler/src/compiler/index.ts

@@ -0,0 +1,3 @@
+export * from './compiler';
+export * from './types';
+export * from './scope';

packages/compiler/src/compiler/scope/index.ts

@@ -0,0 +1,4 @@
+export * from './skip';
+export * from './types';
+export * from './content';
+export * from './attribute';

packages/compiler/src/compiler/types.ts

@@ -0,0 +1,41 @@
+export type ReplexicaCompilerPayload = {
+  settings: {
+    locale: { source: string; };
+  };
+  data: ReplexicaCompilerData;
+};
+
+export type ReplexicaCompilerData = {
+  [fileId: string]: ReplexicaFilePayload;
+};
+
+export type ReplexicaFileContext = {
+  isClient: boolean;
+};
+
+export type ReplexicaFilePayload = {
+  context: ReplexicaFileContext;
+  data: ReplexicaFileData;
+};
+
+export type ReplexicaFileData = {
+  [scopeId: string]: ReplexicaScopePayload;
+}
+
+export type ReplexicaScopePayload = {
+  hints: ReplexicaScopeHint[];
+  data: ReplexicaScopeData;
+};
+
+export type ReplexicaScopeHint = {
+  type: 'attribute';
+  name: string;
+} | {
+  type: 'element';
+  name: string;
+  hint: string | null;
+};
+
+export type ReplexicaScopeData = {
+  [chunkId: string]: string;
+};