@kithinji/pod 1.0.20 → 1.0.22

package/src/plugins/generators/tsx_server_stub.ts

@@ -1,315 +0,0 @@
-import * as path from "path";
-import { createHash } from "crypto";
-import { parseSync, printSync } from "@swc/core";
-import type {
-  ModuleItem,
-  ClassDeclaration,
-  Decorator,
-  ImportDeclaration,
-} from "@swc/core";
-
-interface ClassStub {
-  name: string;
-  propsType: string;
-  decorators: string[];
-  constructorParams: string[];
-}
-
-interface ImportMap {
-  [localName: string]: string;
-}
-
-export function generateServerStub(filePath: string, code: string): string {
-  const hash = createHash("md5").update(filePath).digest("hex").slice(0, 8);
-  const relativeFromSrc = filePath.split("/src/")[1];
-  const parsed = path.parse(relativeFromSrc);
-
-  const fileName = path.join("src", parsed.dir, parsed.name);
-
-  const ast = parseSync(code, {
-    syntax: "typescript",
-    tsx: filePath.endsWith("x"),
-    decorators: true,
-  });
-
-  const importMap: ImportMap = {};
-  for (const item of ast.body) {
-    if (item.type === "ImportDeclaration") {
-      const decl = item as ImportDeclaration;
-      for (const specifier of decl.specifiers ?? []) {
-        let localName: string;
-        if (specifier.type === "ImportSpecifier") {
-          localName = specifier.local.value;
-        } else if (specifier.type === "ImportDefaultSpecifier") {
-          localName = specifier.local.value;
-        } else {
-          continue;
-        }
-        importMap[localName] = decl.source.value;
-      }
-    }
-  }
-
-  const preservedNodes: ModuleItem[] = [];
-  const stubbedClasses: ClassStub[] = [];
-
-  for (const item of ast.body) {
-    let shouldStub = false;
-
-    if (
-      item.type === "ExportDeclaration" &&
-      item.declaration?.type === "ClassDeclaration"
-    ) {
-      const classDecl = item.declaration as ClassDeclaration;
-
-      if (hasComponentDecorator(classDecl.decorators)) {
-        shouldStub = true;
-        const stub = extractClassStub(classDecl);
-        if (stub) {
-          stubbedClasses.push(stub);
-        }
-      }
-    }
-
-    if (!shouldStub) {
-      preservedNodes.push(item);
-    }
-  }
-
-  const preservedCode =
-    preservedNodes.length > 0
-      ? printSync({
-          type: "Module",
-          span: ast.span,
-          body: preservedNodes,
-          interpreter: ast.interpreter,
-        }).code
-      : "";
-
-  const stubCode = stubbedClasses
-    .map((stub) => generateClassCode(stub, hash, fileName))
-    .join("\n\n");
-
-  return `
-${preservedCode}
-${stubCode}
-  `.trim();
-}
-
-function hasComponentDecorator(decorators?: Decorator[]): boolean {
-  if (!decorators) return false;
-  return decorators.some((decorator) => {
-    const expr = decorator.expression;
-    if (expr.type === "Identifier" && expr.value === "Component") {
-      return true;
-    }
-    if (
-      expr.type === "CallExpression" &&
-      expr.callee.type === "Identifier" &&
-      expr.callee.value === "Component"
-    ) {
-      return true;
-    }
-    return false;
-  });
-}
-
-function extractClassStub(classDecl: ClassDeclaration): ClassStub | null {
-  const className = classDecl.identifier?.value;
-  if (!className) return null;
-
-  let propsType = "{}";
-  const decorators: string[] = [];
-  const constructorParams: string[] = [];
-
-  if (classDecl.decorators) {
-    for (const dec of classDecl.decorators) {
-      const str = stringifyDecorator(dec);
-      if (str) decorators.push(str);
-    }
-  }
-
-  for (const member of classDecl.body) {
-    if (member.type === "ClassProperty") {
-      if (member.key.type === "Identifier" && member.key.value === "props") {
-        propsType = extractPropsType(member);
-      }
-    } else if (member.type === "Constructor") {
-      for (const param of member.params) {
-        const paramStr = stringifyParam(param);
-        if (paramStr) constructorParams.push(paramStr);
-      }
-    }
-  }
-
-  return {
-    name: className,
-    propsType,
-    decorators,
-    constructorParams,
-  };
-}
-
-export function stringifyDecorator(decorator: Decorator): string {
-  const exprCode = printSync({
-    type: "Module",
-    span: { start: 0, end: 0, ctxt: 0 },
-    body: [
-      {
-        type: "ExpressionStatement",
-        expression: decorator.expression,
-        span: { start: 0, end: 0, ctxt: 0 },
-      },
-    ],
-    interpreter: "",
-  }).code;
-
-  const cleanCode = exprCode.replace(/^#!.*\n/, "").trim();
-
-  return `@${cleanCode.replace(/;$/, "")}`;
-}
-
-function extractPropsType(member: any): string {
-  const typeAnn = member.typeAnnotation?.typeAnnotation;
-  if (!typeAnn) return "{}";
-
-  if (typeAnn.type === "TsTypeLiteral") {
-    const props: string[] = [];
-    for (const m of typeAnn.members) {
-      if (m.type === "TsPropertySignature") {
-        const key = m.key.type === "Identifier" ? m.key.value : "?";
-        const t = m.typeAnnotation
-          ? stringifyType(m.typeAnnotation.typeAnnotation)
-          : "any";
-        props.push(`${key}: ${t}`);
-      }
-    }
-    return `{ ${props.join("; ")} }`;
-  }
-
-  return stringifyType(typeAnn);
-}
-
-function stringifyParam(param: any): string {
-  let decorators: string[] = [];
-  if (param.decorators) {
-    for (const d of param.decorators) {
-      const str = stringifyDecorator(d);
-      if (str) decorators.push(str);
-    }
-  }
-  const decoratorPrefix = decorators.length ? decorators.join(" ") + " " : "";
-
-  let typeName = "any";
-  let paramName = "";
-  let accessibility = "";
-
-  if (param.type === "TsParameterProperty") {
-    accessibility = param.accessibility || "";
-    const inner = param.param;
-    if (inner.type !== "Identifier") return "";
-
-    paramName = inner.value;
-    if (inner.typeAnnotation?.typeAnnotation) {
-      typeName = extractTypeName(inner.typeAnnotation.typeAnnotation);
-    }
-  } else if (param.type === "Parameter") {
-    const pat = param.pat;
-    if (pat.type !== "Identifier") return "";
-
-    paramName = pat.value;
-    if (pat.typeAnnotation?.typeAnnotation) {
-      typeName = extractTypeName(pat.typeAnnotation.typeAnnotation);
-    }
-  } else {
-    return "";
-  }
-
-  const accessPrefix = accessibility ? `${accessibility} ` : "";
-  const result = `${decoratorPrefix}${accessPrefix}${paramName}: ${typeName}`;
-
-  return result;
-}
-
-function extractTypeName(typeNode: any): string {
-  if (
-    typeNode.type === "TsTypeReference" &&
-    typeNode.typeName.type === "Identifier"
-  ) {
-    return typeNode.typeName.value;
-  }
-  return stringifyType(typeNode);
-}
-
-function stringifyType(typeNode: any): string {
-  if (!typeNode) return "any";
-
-  switch (typeNode.type) {
-    case "TsKeywordType":
-      return typeNode.kind;
-    case "TsTypeReference":
-      if (typeNode.typeName.type === "Identifier")
-        return typeNode.typeName.value;
-      if (typeNode.typeName.type === "TsQualifiedName") {
-        return `${stringifyQualifiedName(typeNode.typeName.left)}.${
-          typeNode.typeName.right.value
-        }`;
-      }
-      return "any";
-    case "TsArrayType":
-      return `${stringifyType(typeNode.elemType)}[]`;
-    case "TsUnionType":
-      return typeNode.types.map(stringifyType).join(" | ");
-    case "TsIntersectionType":
-      return typeNode.types.map(stringifyType).join(" & ");
-    default:
-      return "any";
-  }
-}
-
-function stringifyQualifiedName(node: any): string {
-  if (node.type === "Identifier") return node.value;
-  if (node.type === "TsQualifiedName") {
-    return `${stringifyQualifiedName(node.left)}.${node.right.value}`;
-  }
-  return "any";
-}
-
-function generateClassCode(
-  stub: ClassStub,
-  hash: string,
-  fileName: string
-): string {
-  const clientId = `${stub.name}_${hash}`;
-  const clientPath = `/${fileName}.js`;
-  const decoratorsStr =
-    stub.decorators.length > 0 ? stub.decorators.join("\n") + "\n" : "";
-
-  const constructorStr = stub.constructorParams.length
-    ? `constructor(${stub.constructorParams.join(", ")}) {}`
-    : "constructor() {}";
-
-  return `
-${decoratorsStr}export class ${stub.name} {
-  props!: ${stub.propsType};
-  ${constructorStr}
-  build() {
-    const inputProps = { ...this.props };
-    return {
-      $$typeof: Symbol.for("orca.client.component"),
-      id: "${clientId}_" + Math.random().toString(36).slice(2, 9),
-      type: "${stub.name}",
-      props: {
-        ...inputProps,
-        __clientComponent: {
-          id: "${clientId}",
-          path: "${clientPath}",
-          name: "${stub.name}",
-        }
-      },
-      key: null
-    };
-  }
-}
-`.trim();
-}

package/src/plugins/index.ts

@@ -1,3 +0,0 @@
-export * from "./my";
-export * from "./analyzers/graph";
-export * from "./css";

package/src/plugins/my.ts

@@ -1,282 +0,0 @@
-import type { Plugin, OnLoadArgs, OnLoadResult } from "esbuild";
-import * as fs from "fs/promises";
-import { ReactConfig, transform } from "@swc/core";
-import * as babel from "@babel/core";
-import * as path from "path";
-import { expandMacros } from "@/macros";
-import { DependencyGraph, FileNode } from "./analyzers/graph";
-import { generateController } from "./generators/generate_controller";
-import { generateServerStub } from "./generators/tsx_server_stub";
-import { j2d } from "./transformers/j2d";
-import { generateServerComponent } from "./generators/generate_server_component";
-import { generateRscStub } from "./generators/generate_rsc";
-import { Store } from "@/store";
-
-interface MyPluginParams {
-  isServerBuild: boolean;
-  graph?: DependencyGraph;
-  onClientFound: (path: string) => void;
-}
-
-type FileDirective = "interactive" | "public" | null;
-
-interface FileMetadata {
-  source: string;
-  path: string;
-  isTsx: boolean;
-  directive: FileDirective;
-  isPublicFile: boolean;
-  isInteractiveFile: boolean;
-}
-
-async function swcTransform(
-  source: string,
-  pathStr: string,
-  tsx: boolean = false,
-  react?: ReactConfig
-): Promise<OnLoadResult> {
-  const resolveDir = path.dirname(pathStr);
-
-  const swcResult = await transform(source, {
-    filename: pathStr,
-    jsc: {
-      parser: {
-        syntax: "typescript",
-        tsx,
-        decorators: true,
-      },
-      transform: {
-        legacyDecorator: true,
-        decoratorMetadata: true,
-        react,
-      },
-      target: "esnext",
-    },
-    isModule: true,
-  });
-
-  return {
-    contents: swcResult.code,
-    loader: "js",
-    resolveDir,
-  };
-}
-
-function parseFileMetadata(source: string, path: string): FileMetadata {
-  const isTsx = path.endsWith(".tsx");
-  const isInteractiveFile =
-    source.startsWith('"use interactive"') ||
-    source.startsWith("'use interactive'");
-  const isPublicFile =
-    source.startsWith('"use public"') || source.startsWith("'use public'");
-
-  let directive: FileDirective = null;
-  if (isInteractiveFile) directive = "interactive";
-  else if (isPublicFile) directive = "public";
-
-  return {
-    source,
-    path,
-    isTsx,
-    directive,
-    isPublicFile,
-    isInteractiveFile,
-  };
-}
-
-class ServerBuildTransformer {
-  async transformPublicFile(
-    source: string,
-    path: string
-  ): Promise<OnLoadResult> {
-    const controllerCode = generateController(path, source);
-
-    if (controllerCode) {
-      source = `${source}\n\n${controllerCode}\n`;
-    }
-
-    return swcTransform(source, path);
-  }
-
-  async transformRegularTypeScript(
-    source: string,
-    path: string,
-    isPublic: boolean
-  ): Promise<OnLoadResult> {
-    if (isPublic) {
-      return this.transformPublicFile(source, path);
-    }
-    return swcTransform(source, path);
-  }
-
-  async transformServerTsx(
-    source: string,
-    path: string
-  ): Promise<OnLoadResult> {
-    return swcTransform(source, path, true, {
-      runtime: "automatic",
-      importSource: "@kithinji/orca",
-    });
-  }
-
-  async transformInteractiveTsxStub(
-    source: string,
-    path: string
-  ): Promise<OnLoadResult> {
-    const stubSource = generateServerStub(path, source);
-
-    return swcTransform(stubSource, path);
-  }
-
-  async process(
-    metadata: FileMetadata,
-    onClientFound: (path: string) => void
-  ): Promise<OnLoadResult> {
-    const expandedSource = await expandMacros(metadata.source, metadata.path);
-
-    const expandedMetadata = { ...metadata, source: expandedSource };
-    const { source, path, isTsx, isInteractiveFile, isPublicFile } =
-      expandedMetadata;
-
-    if (isTsx) {
-      if (isInteractiveFile) {
-        onClientFound(path);
-        const clientCode = await this.transformInteractiveTsxStub(source, path);
-
-        const store = Store.getInstance();
-
-        store.set(path, clientCode.contents);
-
-        return clientCode;
-      }
-      return this.transformServerTsx(source, path);
-    }
-
-    return this.transformRegularTypeScript(source, path, isPublicFile);
-  }
-}
-
-class ClientBuildTransformer {
-  async transformInteractiveTsx(
-    source: string,
-    path: string
-  ): Promise<OnLoadResult> {
-    const swcResult = await swcTransform(source, path, true, {
-      runtime: "preserve",
-    });
-
-    const babelResult = await babel.transformAsync(
-      swcResult.contents as string,
-      {
-        filename: path,
-        sourceType: "module",
-        plugins: [j2d],
-        parserOpts: {
-          plugins: ["jsx"],
-        },
-        configFile: false,
-        babelrc: false,
-      }
-    );
-
-    return {
-      contents: babelResult?.code || "",
-      loader: "js",
-      resolveDir: swcResult.resolveDir,
-    };
-  }
-
-  async transformServerComponent(
-    node: FileNode,
-    source: string,
-    path: string
-  ): Promise<OnLoadResult> {
-    const scSource = generateServerComponent(path, source);
-    return swcTransform(scSource, path);
-  }
-
-  async transformPublicFileRsc(
-    node: FileNode,
-    source: string,
-    path: string
-  ): Promise<OnLoadResult> {
-    const stubSource = generateRscStub(path, source);
-    return swcTransform(stubSource, path);
-  }
-
-  async transformSharedCode(
-    source: string,
-    path: string
-  ): Promise<OnLoadResult> {
-    return swcTransform(source, path);
-  }
-
-  async process(node: FileNode, metadata: FileMetadata): Promise<OnLoadResult> {
-    const expandedSource = await expandMacros(metadata.source, metadata.path);
-
-    const expandedMetadata = { ...metadata, source: expandedSource };
-    const { source, path, isTsx, directive } = expandedMetadata;
-
-    if (isTsx) {
-      if (directive === "interactive") {
-        return this.transformInteractiveTsx(source, path);
-      } else if (directive === null) {
-        return this.transformServerComponent(node, source, path);
-      } else {
-        throw new Error(
-          `Unexpected directive "${directive}" for TSX file: ${path}`
-        );
-      }
-    }
-
-    if (directive === "public") {
-      return this.transformPublicFileRsc(node, source, path);
-    }
-
-    if (directive === null) {
-      return this.transformSharedCode(source, path);
-    }
-
-    return {
-      contents: source,
-      loader: isTsx ? "tsx" : "ts",
-    };
-  }
-}
-
-export function useMyPlugin(options: MyPluginParams): Plugin {
-  const serverTransformer = new ServerBuildTransformer();
-  const clientTransformer = new ClientBuildTransformer();
-
-  return {
-    name: "Orca",
-    setup(build) {
-      build.onLoad(
-        { filter: /\.tsx?$/ },
-        async (args: OnLoadArgs): Promise<OnLoadResult> => {
-          const source = await fs.readFile(args.path, "utf8");
-          const metadata = parseFileMetadata(source, args.path);
-
-          if (options.isServerBuild) {
-            return serverTransformer.process(metadata, options.onClientFound);
-          }
-
-          if (!options.graph) {
-            throw new Error(
-              "Dependency graph is required for client build but was not provided"
-            );
-          }
-
-          const node = options.graph[args.path];
-
-          if (!node) {
-            console.log(`File node not found in depend graph: ${args.path}`);
-            throw new Error("900");
-          }
-
-          return clientTransformer.process(node, metadata);
-        }
-      );
-    },
-  };
-}