akanjs 2.0.7 → 2.1.0-rc.0

package/devkit/transforms/externalizeFrameworkPlugin.ts

@@ -1,159 +0,0 @@
-import path from "node:path";
-import type { BunPlugin } from "bun";
-import type { App } from "../commandDecorators";
-
-/**
- * Keep framework/runtime singletons external while bundling authored
- * workspace sources and ordinary npm dependencies into the pages bundle.
- *
- * Why a plugin instead of `Bun.build({ external })` or
- * `Bun.build({ packages: "external" })`:
- *   - `packages: "external"` externalizes every bare specifier, including
- *     `@apps/*` / `@libs/*` — workspace packages that must stay bundled
- *     so the `"use client"` plugin can rewrite their exports — and ordinary
- *     npm dependencies like `dayjs` / `clsx`, which the production runtime
- *     package.json does not install for the SSR pages artifact.
- *   - Top-level `external: [...]` applies to macro-time module resolution
- *     too; any `with { type: "macro" }` import chain that transitively
- *     resolves `react` during build then fails with `ENOENT "react"`.
- *
- * An `onResolve` plugin only participates in the output-graph walk, so
- * macros evaluate against the real modules in node_modules while the
- * emitted bundle keeps bare specifiers only for runtime singletons that
- * are installed in the generated production package.json.
- *
- * Externalization rules (applied in order):
- *   1. Relative specifiers (`./`, `../`) are NEVER externalized — they
- *      always resolve to the current package's source tree and must be
- *      inlined so transitive `"use client"` stubs work.
- *   2. Specifiers listed in `include` (workspace aliases like
- *      `@apps/*`, `@libs/*`) are NEVER externalized.
- *   3. React / RSC runtime packages and framework host packages are
- *      externalized so the runtime supplies a single shared instance.
- *   4. Other bare npm packages are bundled so the Docker runtime does not
- *      need to install every transitive page dependency separately.
- */
-export interface ExternalizeFrameworkOptions {
-  app: App;
-  /**
-   * Prefixes that should be BUNDLED (kept internal). Defaults to
-   * `@apps/` and `@libs/` which are the workspace aliases used by the
-   * framework's app template.
-   */
-  include?: string[];
-  /**
-   * Extra bare specifiers to force-externalize beyond the allowlist
-   * defaults. Not commonly needed since the default rule already
-   * externalizes every non-workspace specifier.
-   */
-  extra?: string[];
-}
-
-const DEFAULT_INCLUDE = ["akanjs/", "@apps/", "@libs/"];
-
-const DEFAULT_EXCLUDE_EXACT = new Set<string>(["akanjs/webkit", "akanjs/server", "akanjs/cli", "akanjs/devkit"]);
-const DEFAULT_EXCLUDE_PREFIX = ["akanjs/server/", "akanjs/cli/", "akanjs/devkit/"];
-const RUNTIME_EXTERNAL_EXACT = new Set<string>([
-  "react",
-  "react-dom",
-  "react/jsx-runtime",
-  "react/jsx-dev-runtime",
-  "react-server-dom-webpack",
-  "react-server-dom-webpack/server.node",
-  "react-server-dom-webpack/client.node",
-  "react-server-dom-webpack/client.browser",
-]);
-const RUNTIME_EXTERNAL_PREFIX = ["react-dom/", "react-server-dom-webpack/"];
-
-const CANDIDATE_EXTS = [".tsx", ".ts", ".jsx", ".js", ".mjs", ".cjs"];
-
-export async function createExternalizeFrameworkPlugin(options: ExternalizeFrameworkOptions): Promise<BunPlugin> {
-  const tsconfig = await options.app.getTsConfig();
-  const includePrefixes = options.include ?? DEFAULT_INCLUDE;
-  const extraExact = new Set(options.extra ?? []);
-  const workspaceRoot = options.app.workspace.workspaceRoot;
-  const tsconfigPaths = tsconfig.compilerOptions.paths ?? {};
-
-  const rootEntries = Object.entries(tsconfigPaths)
-    .filter(([k]) => !k.endsWith("/*"))
-    .map(([k, v]) => ({ pkg: k, entryFile: v[0] ?? null }))
-    .filter((e): e is { pkg: string; entryFile: string } => e.entryFile !== null);
-  const wildcardEntries = Object.entries(tsconfigPaths)
-    .filter(([k]) => k.endsWith("/*"))
-    .map(([k, v]) => ({ prefix: k.slice(0, -1), replacements: v }))
-    .sort((a, b) => b.prefix.length - a.prefix.length);
-
-  async function resolveWorkspaceSubpath(spec: string): Promise<string | null> {
-    if (!workspaceRoot) return null;
-    
-    for (const { prefix, replacements } of wildcardEntries) {
-      if (!spec.startsWith(prefix)) continue;
-      const suffix = spec.slice(prefix.length);
-      for (const repl of replacements) {
-        const replPath = repl?.endsWith("/*") ? repl.slice(0, -1) : (repl ?? "");
-        if (!replPath) continue;
-        const candidate = path.resolve(workspaceRoot, replPath + suffix);
-        const hit = await firstExisting(candidate);
-        if (hit) return hit;
-      }
-    }
-
-    for (const { pkg, entryFile } of rootEntries) {
-      if (spec !== pkg && !spec.startsWith(`${pkg}/`)) continue;
-      if (spec === pkg) continue; 
-      const suffix = spec.slice(pkg.length + 1);
-      const pkgDir = path.dirname(path.resolve(workspaceRoot, entryFile));
-      const candidate = path.join(pkgDir, suffix);
-      const hit = await firstExisting(candidate);
-      if (hit) return hit;
-    }
-    return null;
-  }
-
-  return {
-    name: "akan-externalize-framework",
-    setup(build) {
-      build.onResolve({ filter: /.*/ }, async (args) => {
-        const spec = args.path;
-
-        if (spec === "." || spec === ".." || spec.startsWith("./") || spec.startsWith("../") || spec.startsWith("/"))
-          return undefined;
-        
-        if (extraExact.has(spec) || DEFAULT_EXCLUDE_EXACT.has(spec)) return { path: spec, external: true };
-        for (const prefix of DEFAULT_EXCLUDE_PREFIX) {
-          if (spec.startsWith(prefix)) return { path: spec, external: true };
-        }
-        if (RUNTIME_EXTERNAL_EXACT.has(spec)) return { path: spec, external: true };
-        for (const prefix of RUNTIME_EXTERNAL_PREFIX) {
-          if (spec.startsWith(prefix)) return { path: spec, external: true };
-        }
-
-        for (const prefix of includePrefixes) {
-          if (!spec.startsWith(prefix)) continue;
-          const resolved = await resolveWorkspaceSubpath(spec);
-          if (resolved) return { path: resolved };
-
-          return undefined;
-        }
-
-        return undefined;
-      });
-    },
-  };
-}
-
-async function firstExisting(basePath: string): Promise<string | null> {
-  
-  if (await Bun.file(basePath).exists()) return basePath;
-  
-  for (const ext of CANDIDATE_EXTS) {
-    const candidate = `${basePath}${ext}`;
-    if (await Bun.file(candidate).exists()) return candidate;
-  }
-  
-  for (const ext of CANDIDATE_EXTS) {
-    const candidate = path.join(basePath, `index${ext}`);
-    if (await Bun.file(candidate).exists()) return candidate;
-  }
-  return null;
-}

package/devkit/transforms/index.ts

@@ -1,5 +0,0 @@
-export * from "./barrelAnalyzer";
-export * from "./barrelImportsPlugin";
-export * from "./externalizeFrameworkPlugin";
-export * from "./rscUseClientTransform";
-export * from "./useClientBundlePlugin";

package/devkit/transforms/rscUseClientTransform.ts

@@ -1,52 +0,0 @@
-import path from "node:path";
-
-const USE_CLIENT_RE = /^\s*(?:\/\*[\s\S]*?\*\/\s*|\/\/[^\n]*\n\s*)*["']use client["']/;
-const IMPLICIT_ROOT_LAYOUT_RE =
-  /[/\\]\.akan[/\\]generated[/\\](?:implicit-root-layout|root-layouts[/\\].*__root_layout)\.(tsx|ts|jsx|js)$/;
-
-export interface UseClientTransformArgs {
-  path: string;
-  workspaceRoot?: string;
-}
-
-export function toClientReferencePath(absPath: string, workspaceRoot: string): string {
-  return path.relative(path.resolve(workspaceRoot), path.resolve(absPath)).split(path.sep).join("/");
-}
-
-/**
- * Returns the stubbed module source if `source` is a client module, else null.
- * The returned source is TypeScript-compatible (loader "ts" is safe).
- */
-export function transformUseClient(source: string, args: UseClientTransformArgs): string | null {
-  if (!USE_CLIENT_RE.test(source)) return null;
-  if (IMPLICIT_ROOT_LAYOUT_RE.test(args.path)) return null;
-  const transpiler = new Bun.Transpiler({ loader: loaderFor(args.path) });
-  const { exports } = transpiler.scan(source);
-  if (exports.length === 0) return null;
-
-  const referencePath = args.workspaceRoot ? toClientReferencePath(args.path, args.workspaceRoot) : args.path;
-  const filePathLit = JSON.stringify(referencePath);
-  const lines: string[] = [`import { registerClientReference } from "react-server-dom-webpack/server.node";`];
-
-  for (const name of exports) {
-    const nameLit = JSON.stringify(name);
-    const errMsg = JSON.stringify(
-      `Attempted to call '${name}' from '${referencePath}' on the server, but it is a client-only export.`,
-    );
-    const proxy = `() => { throw new Error(${errMsg}); }`;
-    const binding =
-      name === "default"
-        ? `export default registerClientReference(${proxy}, ${filePathLit}, ${nameLit});`
-        : `export const ${name} = registerClientReference(${proxy}, ${filePathLit}, ${nameLit});`;
-    lines.push(binding);
-  }
-
-  return lines.join("\n");
-}
-
-function loaderFor(absPath: string): "ts" | "tsx" | "js" | "jsx" {
-  if (absPath.endsWith(".tsx")) return "tsx";
-  if (absPath.endsWith(".jsx")) return "jsx";
-  if (absPath.endsWith(".ts")) return "ts";
-  return "js";
-}

package/devkit/transforms/useClientBundlePlugin.ts

@@ -1,47 +0,0 @@
-import type { BunPlugin } from "bun";
-import { transformUseClient } from "./rscUseClientTransform";
-
-/**
- * BunPlugin that stubs `"use client"` modules so the server bundle sees
- * `registerClientReference(proxy, absPath, name)` stubs instead of the
- * original client code.
- *
- * The bundle produced by `PagesBundleBuilder` is loaded in the RSC worker
- * with `--conditions react-server`; client components are never supposed
- * to execute there. The resulting stub references keep the client
- * component manifest lookups working at render time while ensuring the
- * server bundle never drags the real client source graph in.
- *
- * Important: the second argument to `registerClientReference` must match the
- * key the client manifest uses. When `workspaceRoot` is provided, both sides
- * use workspace-relative keys so production artifacts are portable.
- */
-export function createUseClientBundlePlugin(options: { workspaceRoot?: string } = {}): BunPlugin {
-  return {
-    name: "akan-use-client-bundle",
-    setup(build) {
-      build.onLoad({ filter: /\.(tsx|ts|jsx|js)$/ }, async (args) => {
-        if (args.path.includes("/node_modules/")) return undefined;
-        let source: string;
-        try {
-          source = await Bun.file(args.path).text();
-        } catch {
-          return undefined;
-        }
-        const stubbed = transformUseClient(source, {
-          path: args.path,
-          workspaceRoot: options.workspaceRoot,
-        });
-        if (stubbed === null) return undefined;
-        return { contents: stubbed, loader: loaderFor(args.path) };
-      });
-    },
-  };
-}
-
-function loaderFor(absPath: string): "ts" | "tsx" | "js" | "jsx" {
-  if (absPath.endsWith(".tsx")) return "tsx";
-  if (absPath.endsWith(".jsx")) return "jsx";
-  if (absPath.endsWith(".ts")) return "ts";
-  return "js";
-}

package/devkit/typeChecker.ts

@@ -1,260 +0,0 @@
-import { readFileSync } from "node:fs";
-import * as path from "node:path";
-import chalk from "chalk";
-import * as ts from "typescript";
-
-import type { Executor } from "./executors";
-
-export interface ProjectTypecheckResult {
-  configPath: string;
-  diagnostics: ts.Diagnostic[];
-  errors: ts.Diagnostic[];
-  warnings: ts.Diagnostic[];
-  message: string;
-}
-
-export class TypeChecker {
-  readonly configPath: string;
-  readonly configFile: { config?: any; error?: ts.Diagnostic };
-  readonly config: ts.ParsedCommandLine;
-  constructor(executor: Executor) {
-    const configPath = this.#findConfigFile(executor.cwdPath);
-    if (!configPath) throw new Error("No tsconfig.json found in the project");
-    this.configPath = configPath;
-    this.configFile = ts.readConfigFile(this.configPath, (fileName) => ts.sys.readFile(fileName));
-    const parsedConfig = ts.parseJsonConfigFileContent(
-      this.configFile.config,
-      ts.sys,
-      path.dirname(this.configPath),
-      undefined,
-      this.configPath,
-    );
-
-    if (parsedConfig.errors.length > 0) {
-      const errorMessages = parsedConfig.errors
-        .map((error) => ts.flattenDiagnosticMessageText(error.messageText, "\n"))
-        .join("\n");
-      throw new Error(`Error parsing tsconfig.json:\n${errorMessages}`);
-    }
-    this.config = parsedConfig;
-  }
-  /**
-   * Find tsconfig.json by walking up the directory tree
-   */
-  #findConfigFile(searchPath: string): string | undefined {
-    return ts.findConfigFile(searchPath, (fileName) => ts.sys.fileExists(fileName), "tsconfig.json");
-  }
-
-  /**
-   * Type-check a single TypeScript file
-   * @param filePath - Path to the TypeScript file to check
-   * @returns Array of diagnostic messages
-   */
-  check(filePath: string): {
-    diagnostics: ts.Diagnostic[];
-    errors: ts.Diagnostic[];
-    warnings: ts.Diagnostic[];
-    fileDiagnostics: ts.Diagnostic[];
-    fileErrors: ts.Diagnostic[];
-    fileWarnings: ts.Diagnostic[];
-  } {
-    const program = ts.createProgram([filePath], this.config.options);
-    const diagnostics = [
-      ...program.getSemanticDiagnostics(),
-      ...program.getSyntacticDiagnostics(),
-      
-      ...(this.config.options.declaration ? program.getDeclarationDiagnostics() : []),
-    ];
-    const errors = diagnostics.filter((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Error);
-    const warnings = diagnostics.filter((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Warning);
-    const fileDiagnostics = diagnostics.filter((diagnostic) => diagnostic.file?.fileName === filePath);
-    const fileErrors = fileDiagnostics.filter((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Error);
-    const fileWarnings = fileDiagnostics.filter((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Warning);
-    return { diagnostics, errors, warnings, fileDiagnostics, fileErrors, fileWarnings };
-  }
-
-  /**
-   * Format diagnostics for console output
-   * @param diagnostics - Array of TypeScript diagnostics
-   * @returns Formatted string
-   */
-  formatDiagnostics(diagnostics: ts.Diagnostic[]): string {
-    if (diagnostics.length === 0) return chalk.bold("✅ No type errors found");
-
-    const output: string[] = [];
-    let errorCount = 0;
-    let warningCount = 0;
-    let suggestionCount = 0;
-
-    const diagnosticsByFile = new Map<string, ts.Diagnostic[]>();
-    diagnostics.forEach((diagnostic) => {
-      if (diagnostic.category === ts.DiagnosticCategory.Error) errorCount++;
-      else if (diagnostic.category === ts.DiagnosticCategory.Warning) warningCount++;
-      else if (diagnostic.category === ts.DiagnosticCategory.Suggestion) suggestionCount++;
-
-      if (diagnostic.file) {
-        const fileName = diagnostic.file.fileName;
-        if (!diagnosticsByFile.has(fileName)) diagnosticsByFile.set(fileName, []);
-        const fileDiagnostics = diagnosticsByFile.get(fileName);
-        if (fileDiagnostics) fileDiagnostics.push(diagnostic);
-      } else {
-        if (!diagnosticsByFile.has("")) diagnosticsByFile.set("", []);
-        const fileDiagnostics = diagnosticsByFile.get("");
-        if (fileDiagnostics) fileDiagnostics.push(diagnostic);
-      }
-    });
-
-    diagnosticsByFile.forEach((fileDiagnostics, fileName) => {
-      if (fileName) output.push(`\n${chalk.cyan(fileName)}`);
-
-      fileDiagnostics.forEach((diagnostic) => {
-        const categoryText =
-          diagnostic.category === ts.DiagnosticCategory.Error
-            ? "error"
-            : diagnostic.category === ts.DiagnosticCategory.Warning
-              ? "warning"
-              : "suggestion";
-        const categoryColor =
-          diagnostic.category === ts.DiagnosticCategory.Error
-            ? chalk.red
-            : diagnostic.category === ts.DiagnosticCategory.Warning
-              ? chalk.yellow
-              : chalk.blue;
-        const icon =
-          diagnostic.category === ts.DiagnosticCategory.Error
-            ? "❌"
-            : diagnostic.category === ts.DiagnosticCategory.Warning
-              ? "⚠️"
-              : "💡";
-        const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
-        const tsCode = chalk.dim(`(TS${diagnostic.code})`);
-
-        if (diagnostic.file && diagnostic.start !== undefined) {
-          const { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
-
-          output.push(`\n  ${icon} ${categoryColor(categoryText)}: ${message} ${tsCode}`);
-          output.push(`     ${chalk.gray("at")} ${fileName}:${chalk.bold(`${line + 1}:${character + 1}`)}`);
-
-          const sourceLines = diagnostic.file.text.split("\n");
-          if (line < sourceLines.length) {
-            const sourceLine = sourceLines[line];
-            const lineNumber = (line + 1).toString().padStart(5, " ");
-
-            output.push(`\n${chalk.dim(`${lineNumber} |`)} ${sourceLine}`);
-
-            const underlinePrefix = " ".repeat(character);
-            const length = diagnostic.length ?? 1;
-            const underline = "~".repeat(Math.max(1, length));
-
-            output.push(
-              `${chalk.dim(`${" ".repeat(lineNumber.length)} |`)} ${underlinePrefix}${categoryColor(underline)}`,
-            );
-          }
-        } else output.push(`\n  ${icon} ${categoryColor(categoryText)}: ${message} ${tsCode}`);
-      });
-    });
-
-    const summary = [] as string[];
-    if (errorCount > 0) summary.push(chalk.red(`${errorCount} error(s)`));
-    if (warningCount > 0) summary.push(chalk.yellow(`${warningCount} warning(s)`));
-    if (suggestionCount > 0) summary.push(chalk.blue(`${suggestionCount} suggestion(s)`));
-
-    return `\n${summary.join(", ")} found${output.join("\n")}`;
-  }
-
-  /**
-   * Get detailed diagnostic information with code snippet
-   * @param filePath - Path to the TypeScript file to check
-   * @returns Object containing diagnostics and detailed information
-   */
-  getDetailedDiagnostics(filePath: string): {
-    diagnostics: ts.Diagnostic[];
-    details: { line: number; column: number; message: string; code: number; codeSnippet?: string }[];
-  } {
-    const { diagnostics } = this.check(filePath);
-    const sourceFile = ts.createSourceFile(filePath, readFileSync(filePath, "utf8"), ts.ScriptTarget.Latest, true);
-
-    const details = diagnostics.map((diagnostic) => {
-      if (diagnostic.file && diagnostic.start !== undefined) {
-        const { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
-        const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
-
-        const lines = sourceFile.text.split("\n");
-        const codeSnippet = line < lines.length ? lines[line] : undefined;
-        return { line: line + 1, column: character + 1, message, code: diagnostic.code, codeSnippet };
-      }
-
-      return {
-        line: 0,
-        column: 0,
-        message: ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n"),
-        code: diagnostic.code,
-      };
-    });
-
-    return { diagnostics, details };
-  }
-
-  /**
-   * Check if a file has type errors
-   * @param filePath - Path to the TypeScript file to check
-   * @returns true if there are no type errors, false otherwise
-   */
-  hasNoTypeErrors(filePath: string): boolean {
-    try {
-      const { diagnostics } = this.check(filePath);
-      return diagnostics.length === 0;
-    } catch (error) {
-      return false;
-    }
-  }
-
-  static checkProject(configPath: string): ProjectTypecheckResult {
-    const parsedConfig = TypeChecker.parseConfig(configPath);
-    const host = ts.createIncrementalCompilerHost(parsedConfig.options);
-    const builderProgram = ts.createIncrementalProgram({
-      rootNames: parsedConfig.fileNames,
-      options: parsedConfig.options,
-      projectReferences: parsedConfig.projectReferences,
-      configFileParsingDiagnostics: parsedConfig.errors,
-      host,
-    });
-    const program = builderProgram.getProgram();
-    const diagnostics = [...ts.getPreEmitDiagnostics(program), ...builderProgram.emit().diagnostics];
-    const errors = diagnostics.filter((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Error);
-    const warnings = diagnostics.filter((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Warning);
-    return {
-      configPath,
-      diagnostics,
-      errors,
-      warnings,
-      message: TypeChecker.formatDiagnosticMessages(diagnostics),
-    };
-  }
-
-  static parseConfig(configPath: string): ts.ParsedCommandLine {
-    const configFile = ts.readConfigFile(configPath, (fileName) => ts.sys.readFile(fileName));
-    const configDiagnostics = configFile.error ? [configFile.error] : [];
-    if (!configFile.config) {
-      const message = TypeChecker.formatDiagnosticMessages(configDiagnostics);
-      throw new Error(message || `Error reading tsconfig.json: ${configPath}`);
-    }
-    const parsedConfig = ts.parseJsonConfigFileContent(
-      configFile.config,
-      ts.sys,
-      path.dirname(configPath),
-      undefined,
-      configPath,
-    );
-    if (parsedConfig.errors.length > 0) throw new Error(TypeChecker.formatDiagnosticMessages(parsedConfig.errors));
-    return parsedConfig;
-  }
-
-  static formatDiagnosticMessages(diagnostics: ts.Diagnostic[]): string {
-    return ts.formatDiagnosticsWithColorAndContext(diagnostics, {
-      getCanonicalFileName: (fileName) => fileName,
-      getCurrentDirectory: () => process.cwd(),
-      getNewLine: () => ts.sys.newLine,
-    });
-  }
-}

package/devkit/types.ts

@@ -1,44 +0,0 @@
-export interface PackageJson {
-  name: string;
-  type?: "module" | "commonjs";
-  version: string;
-  main?: string;
-  description: string;
-  scripts?: Record<string, string>;
-  dependencies?: Record<string, string>;
-  devDependencies?: Record<string, string>;
-  peerDependencies?: Record<string, string>;
-  peerDependenciesMeta?: Record<string, { optional?: boolean }>;
-  optionalDependencies?: Record<string, string>;
-  engines?: Record<string, string>;
-  exports?: Record<string, string | Record<string, string>>;
-  bun?: {
-    platform?: "node" | "browser" | "bun";
-  };
-  [key: string]: unknown;
-}
-
-export interface TsConfigJson {
-  extends?: string;
-  compilerOptions: {
-    target: string;
-    paths?: Record<string, string[]>;
-  };
-  references?: {
-    path: string;
-  }[];
-}
-
-export interface FileContent {
-  filePath: string;
-  content: string;
-}
-
-export interface BaseDevEnv {
-  workspaceRoot: string | undefined;
-  repoName: string;
-  serveDomain: string;
-  env: "testing" | "debug" | "develop" | "main" | "local";
-  portOffset: number;
-  appName?: string | undefined;
-}