@kithinji/pod 1.0.11 → 1.0.13

package/dist/main.js

@@ -1215,6 +1215,7 @@ function extractClassStub(classDecl) {
   if (!className) return null;
   let propsType = "{}";
   const decorators = [];
+  const constructorParams = [];
   if (classDecl.decorators) {
     for (const dec of classDecl.decorators) {
       const str = stringifyDecorator(dec);
@@ -1226,23 +1227,35 @@ function extractClassStub(classDecl) {
       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
+    decorators,
+    constructorParams
   };
 }
 function stringifyDecorator(decorator) {
-  const expr = decorator.expression;
-  if (expr.type === "CallExpression" && expr.callee.type === "Identifier") {
-    return `@${expr.callee.value}()`;
-  }
-  if (expr.type === "Identifier") {
-    return `@${expr.value}`;
-  }
-  return "";
+  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) {
   const typeAnn = member.typeAnnotation?.typeAnnotation;
@@ -1260,6 +1273,46 @@ function extractPropsType(member) {
   }
   return stringifyType2(typeAnn);
 }
+function stringifyParam(param) {
+  let decorators = [];
+  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) {
+  if (typeNode.type === "TsTypeReference" && typeNode.typeName.type === "Identifier") {
+    return typeNode.typeName.value;
+  }
+  return stringifyType2(typeNode);
+}
 function stringifyType2(typeNode) {
   if (!typeNode) return "any";
   switch (typeNode.type) {
@@ -1293,10 +1346,11 @@ function generateClassCode(stub, hash, fileName) {
   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};
-  constructor() {}
+  ${constructorStr}
   build() {
     const inputProps = { ...this.props };
     return {
@@ -2561,7 +2615,10 @@ ${controllerCode}
     if (isTsx) {
       if (isInteractiveFile) {
         onClientFound(path14);
-        return this.transformInteractiveTsxStub(source, path14);
+        const clientCode = await this.transformInteractiveTsxStub(source, path14);
+        const store = Store.getInstance();
+        store.set(path14, clientCode.contents);
+        return clientCode;
       }
       return this.transformServerTsx(source, path14);
     }
@@ -2651,9 +2708,8 @@ function useMyPlugin(options) {
           }
           const node = options.graph[args.path];
           if (!node) {
-            throw new Error(
-              `File node not found in dependency graph: ${args.path}`
-            );
+            console.log(`File node not found in depend graph: ${args.path}`);
+            throw new Error("900");
           }
           return clientTransformer.process(node, metadata);
         }
@@ -2667,54 +2723,55 @@ import { parseSync as parseSync5 } from "@swc/core";
 import * as fs3 from "fs";
 import * as path7 from "path";
 function resolveFilePath(fromFile, importPath) {
-  if (!importPath.startsWith(".")) {
-    return null;
-  }
+  if (!importPath.startsWith(".")) return null;
   const dir = path7.dirname(fromFile);
   const basePath = path7.resolve(dir, importPath);
   const extensions = ["", ".ts", ".tsx", ".js", ".jsx"];
   for (const ext of extensions) {
     const fullPath = basePath + ext;
-    if (fs3.existsSync(fullPath) && fs3.statSync(fullPath).isFile()) {
+    if (fs3.existsSync(fullPath) && fs3.statSync(fullPath).isFile())
       return fullPath;
-    }
   }
   const indexFiles = ["/index.ts", "/index.tsx", "/index.js", "/index.jsx"];
   for (const indexFile of indexFiles) {
     const fullPath = basePath + indexFile;
-    if (fs3.existsSync(fullPath)) {
+    if (fs3.existsSync(fullPath) && fs3.statSync(fullPath).isFile())
       return fullPath;
-    }
   }
   return null;
 }
 function extractDecorators(decorators) {
-  if (!decorators || decorators.length === 0) return [];
-  return decorators.map((decorator) => {
-    if (decorator.expression.type === "CallExpression") {
-      if (decorator.expression.callee.type === "Identifier") {
-        return decorator.expression.callee.value;
-      }
-    } else if (decorator.expression.type === "Identifier") {
-      return decorator.expression.value;
-    }
+  if (!decorators) return [];
+  return decorators.map((d) => {
+    const exp = d.expression;
+    if (exp.type === "CallExpression" && exp.callee.type === "Identifier")
+      return exp.callee.value;
+    if (exp.type === "Identifier") return exp.value;
     return "unknown";
-  }).filter((name) => name !== "unknown");
+  }).filter((n) => n !== "unknown");
 }
 function extractDirective(ast) {
   for (const item of ast.body) {
     if (item.type === "ExpressionStatement" && item.expression.type === "StringLiteral") {
-      const value = item.expression.value;
-      if (value === "use public") return "public";
-      if (value === "use interactive") return "interactive";
-    }
-    if (item.type !== "ExpressionStatement" || item.expression.type !== "StringLiteral") {
+      const val = item.expression.value;
+      if (val === "use public") return "public";
+      if (val === "use interactive") return "interactive";
+    } else {
       break;
     }
   }
   return null;
 }
-function extractExports(ast) {
+function extractImports(ast) {
+  const imports = [];
+  for (const item of ast.body) {
+    if (item.type === "ImportDeclaration") {
+      imports.push({ path: item.source.value, specifiers: item.specifiers });
+    }
+  }
+  return imports;
+}
+function extractExports(ast, currentFile, graph, processFile) {
   const exports = [];
   for (const item of ast.body) {
     if (item.type === "ExportDeclaration" && item.declaration) {
@@ -2742,10 +2799,30 @@ function extractExports(ast) {
         exports.push({ name: decl.id.value, kind: "enum" });
       }
     }
-    if (item.type === "ExportNamedDeclaration") {
-      for (const spec of item.specifiers) {
-        if (spec.type === "ExportSpecifier") {
-          exports.push({ name: spec.orig.value, kind: "unknown" });
+    if (item.type === "ExportNamedDeclaration" && item.source) {
+      const resolved = resolveFilePath(currentFile, item.source.value);
+      if (resolved) {
+        processFile(resolved);
+        const sourceExports = graph[resolved]?.exports || [];
+        for (const spec of item.specifiers) {
+          if (spec.type === "ExportSpecifier") {
+            const exp = sourceExports.find((e) => e.name === spec.orig.value);
+            exports.push({
+              name: spec.exported?.value || spec.orig.value,
+              kind: exp?.kind || "unknown",
+              decorators: exp?.decorators
+            });
+          }
+        }
+      }
+    }
+    if (item.type === "ExportAllDeclaration") {
+      const resolved = resolveFilePath(currentFile, item.source.value);
+      if (resolved) {
+        processFile(resolved);
+        const sourceExports = graph[resolved]?.exports || [];
+        for (const exp of sourceExports) {
+          exports.push({ ...exp });
         }
       }
     }
@@ -2765,7 +2842,7 @@ function extractExports(ast) {
         name: "default",
         kind,
         isDefault: true,
-        decorators: decorators && decorators.length > 0 ? decorators : void 0
+        decorators: decorators?.length ? decorators : void 0
       });
     }
     if (item.type === "ExportDefaultExpression") {
@@ -2774,95 +2851,66 @@ function extractExports(ast) {
   }
   return exports;
 }
-function extractImports(ast) {
-  const imports = [];
-  for (const item of ast.body) {
-    if (item.type === "ImportDeclaration") {
-      imports.push({
-        path: item.source.value,
-        specifiers: item.specifiers
-      });
-    }
-  }
-  return imports;
-}
 function buildGraph(entryPoints) {
   const graph = {};
   const visited = /* @__PURE__ */ new Set();
   function processFile(filePath) {
-    const allowed = filePath.endsWith(".ts") || filePath.endsWith(".tsx") || filePath.endsWith(".js") || filePath.endsWith(".jsx");
-    if (!allowed) return;
+    const allowedExt = [".ts", ".tsx", ".js", ".jsx"];
+    if (!allowedExt.includes(path7.extname(filePath))) return;
     if (visited.has(filePath)) return;
     visited.add(filePath);
     if (!fs3.existsSync(filePath)) {
       console.warn(`File not found: ${filePath}`);
       return;
     }
-    const isTsx = filePath.endsWith(".tsx") || filePath.endsWith(".jsx");
-    const content = fs3.readFileSync(filePath, "utf-8");
+    const isTsx = [".tsx", ".jsx"].includes(path7.extname(filePath));
+    const store = Store.getInstance();
+    const newCode = store.get(filePath);
+    const content = newCode ? newCode[0] : fs3.readFileSync(filePath, "utf-8");
     const ast = parseSync5(content, {
       syntax: "typescript",
       tsx: isTsx,
       decorators: true
     });
     const directive = extractDirective(ast);
-    const exports = extractExports(ast);
     const rawImports = extractImports(ast);
+    const exports = extractExports(ast, filePath, graph, processFile);
     for (const { path: importPath } of rawImports) {
       const resolved = resolveFilePath(filePath, importPath);
-      if (resolved) {
-        processFile(resolved);
-      }
-    }
-    const imports = [];
-    for (const { path: importPath, specifiers } of rawImports) {
-      const resolvedPath = resolveFilePath(filePath, importPath);
-      const sourceExports = resolvedPath && graph[resolvedPath] ? graph[resolvedPath].exports : [];
-      const symbols = [];
-      for (const spec of specifiers) {
-        if (spec.type === "ImportDefaultSpecifier") {
-          const defaultExport = sourceExports.find((e) => e.isDefault);
-          symbols.push({
-            name: spec.local.value,
-            kind: defaultExport?.kind || "unknown",
-            decorators: defaultExport?.decorators,
-            isDefault: true
-          });
-        } else if (spec.type === "ImportNamespaceSpecifier") {
-          symbols.push({
-            name: spec.local.value,
-            kind: "namespace"
-          });
-        } else if (spec.type === "ImportSpecifier") {
-          const importedName = spec.imported ? spec.imported.value : spec.local.value;
-          const exportedSymbol = sourceExports.find(
-            (e) => e.name === importedName
-          );
-          symbols.push({
-            name: importedName,
-            kind: exportedSymbol?.kind || "unknown",
-            decorators: exportedSymbol?.decorators
-          });
+      if (resolved) processFile(resolved);
+    }
+    const imports = rawImports.map(
+      ({ path: importPath, specifiers }) => {
+        const resolvedPath = resolveFilePath(filePath, importPath);
+        const sourceExports = resolvedPath && graph[resolvedPath] ? graph[resolvedPath].exports : [];
+        const symbols = [];
+        for (const spec of specifiers) {
+          if (spec.type === "ImportDefaultSpecifier") {
+            const def = sourceExports.find((e) => e.isDefault);
+            symbols.push({
+              name: spec.local.value,
+              kind: def?.kind || "unknown",
+              decorators: def?.decorators,
+              isDefault: true
+            });
+          } else if (spec.type === "ImportNamespaceSpecifier") {
+            symbols.push({ name: spec.local.value, kind: "namespace" });
+          } else if (spec.type === "ImportSpecifier") {
+            const importedName = spec.imported ? spec.imported.value : spec.local.value;
+            const exp = sourceExports.find((e) => e.name === importedName);
+            symbols.push({
+              name: importedName,
+              kind: exp?.kind || "unknown",
+              decorators: exp?.decorators
+            });
+          }
         }
+        return { sourcePath: importPath, resolvedPath, symbols };
       }
-      imports.push({
-        sourcePath: importPath,
-        resolvedPath,
-        symbols
-      });
-    }
-    graph[filePath] = {
-      filePath,
-      isTsx,
-      directive,
-      imports,
-      exports
-    };
-  }
-  for (const entry of entryPoints) {
-    const resolved = path7.resolve(entry);
-    processFile(resolved);
+    );
+    graph[filePath] = { filePath, isTsx, directive, imports, exports };
   }
+  for (const entry of entryPoints) processFile(path7.resolve(entry));
   return graph;
 }
 
@@ -4491,7 +4539,7 @@ function printNextSteps(projectName, env, services) {
 
 // src/main.ts
 var program = new Command();
-program.name("pod").description("Pod cli tool").version("1.0.11");
+program.name("pod").description("Pod cli tool").version("1.0.13");
 program.command("new <name>").description("Start a new Pod Project").action(async (name) => {
   await addNew(name);
   const appDir = path13.resolve(process.cwd(), name);