akanjs 2.0.0-rc.6 → 2.0.0

package/devkit/dependencyScanner.ts

@@ -1,9 +1,15 @@
+import { builtinModules } from "node:module";
 import * as path from "node:path";
 import ignore from "ignore";
+import ts from "typescript";
 import type { App, Lib, Pkg } from "./commandDecorators";
 import { FileSys } from "./fileSys";
 import type { PackageJson, TsConfigJson } from "./types";
 
+const testFileRegex = /\.(?:test|spec)\.[cm]?[tj]sx?$/;
+const builtinModuleSet = new Set([...builtinModules, ...builtinModules.map((mod) => `node:${mod}`)]);
+const stripShebang = (source: string) => source.replace(/^#!.*(?:\r?\n|$)/, "");
+
 export class TypeScriptDependencyScanner {
   #fileDependencies = new Map<string, string[]>();
   #fileRuntimeDependencies = new Map<string, string[]>();
@@ -57,6 +63,47 @@ export class TypeScriptDependencyScanner {
     };
   }
 
+  async getPackageBuildDependencies(
+    projectName: string,
+  ): Promise<{ npmDeps: string[]; npmDevDeps: string[]; missingDeps: string[] }> {
+    const runtimeDeps = new Set<string>();
+    const devDeps = new Set<string>();
+    const sourceFiles = await this.#findTypeScriptFiles(this.directory, {
+      excludeBuildFiles: true,
+      excludeTestFiles: true,
+    });
+    const cssFiles = await this.#findCssFiles(this.directory);
+
+    for (const filePath of sourceFiles) {
+      const fileContent = await FileSys.readText(filePath);
+      const { imports, typeImports } = this.#extractImports(fileContent, filePath);
+      this.#addNormalizedImports(runtimeDeps, imports, projectName);
+      this.#addNormalizedImports(devDeps, typeImports, projectName);
+    }
+
+    for (const filePath of cssFiles) {
+      const fileContent = await FileSys.readText(filePath);
+      this.#addNormalizedImports(runtimeDeps, this.#extractCssPluginImports(fileContent), projectName);
+    }
+
+    const buildFilePath = path.join(this.directory, "build.ts");
+    if (await FileSys.fileExists(buildFilePath)) {
+      const fileContent = await FileSys.readText(buildFilePath);
+      const { imports, typeImports } = this.#extractImports(fileContent, buildFilePath);
+      this.#addNormalizedImports(devDeps, [...imports, ...typeImports], projectName);
+    }
+
+    for (const dep of runtimeDeps) devDeps.delete(dep);
+
+    const rootDeps = { ...this.rootPackageJson.dependencies, ...this.rootPackageJson.devDependencies };
+    const missingDeps = [...runtimeDeps, ...devDeps].filter((dep) => !rootDeps[dep]).sort();
+    return {
+      npmDeps: [...runtimeDeps].sort(),
+      npmDevDeps: [...devDeps].sort(),
+      missingDeps,
+    };
+  }
+
   async getImportSets<DepSets extends Set<string>[]>(depSets: DepSets): Promise<DepSets> {
     const fileDependencies = await this.getDependencies();
     return this.#getImportSetsFromDependencies(depSets, fileDependencies);
@@ -101,11 +148,35 @@ export class TypeScriptDependencyScanner {
     return this.#fileDependencies;
   }
 
-  async #findTypeScriptFiles(directory: string): Promise<string[]> {
+  async #findTypeScriptFiles(
+    directory: string,
+    {
+      excludeBuildFiles = false,
+      excludeTestFiles = false,
+    }: { excludeBuildFiles?: boolean; excludeTestFiles?: boolean } = {},
+  ): Promise<string[]> {
     const files: string[] = [];
     const skipDirs = ["node_modules", "dist", "build", ".git", ".next", "public", "ios", "android"];
 
     const glob = new Bun.Glob("**/*.{ts,tsx}");
+    for await (const filePath of glob.scan({ cwd: directory, onlyFiles: true })) {
+      if (skipDirs.some((dir) => filePath.includes(`/${dir}/`) || filePath.startsWith(`${dir}/`))) continue;
+      if (excludeBuildFiles && filePath === "build.ts") continue;
+      if (excludeTestFiles && testFileRegex.test(filePath)) continue;
+
+      const fullPath = path.join(directory, filePath);
+      const relativePath = path.relative(this.workspaceRoot, fullPath);
+      if (this.ig.ignores(relativePath)) continue;
+
+      files.push(fullPath);
+    }
+    return files;
+  }
+
+  async #findCssFiles(directory: string): Promise<string[]> {
+    const files: string[] = [];
+    const skipDirs = ["node_modules", "dist", "build", ".git", ".next", "public", "ios", "android"];
+    const glob = new Bun.Glob("**/*.css");
     for await (const filePath of glob.scan({ cwd: directory, onlyFiles: true })) {
       if (skipDirs.some((dir) => filePath.includes(`/${dir}/`) || filePath.startsWith(`${dir}/`))) continue;
 
@@ -160,27 +231,29 @@ export class TypeScriptDependencyScanner {
 
   #extractImports(source: string, filePath: string) {
     const transpiler = filePath.endsWith(".tsx") ? this.#tsxTranspiler : this.#tsTranspiler;
+    const scanSource = stripShebang(source);
     const imports = new Set(
       transpiler
-        .scanImports(source)
+        .scanImports(scanSource)
         .map((imp) => imp.path)
         .filter(Boolean),
     );
     const typeImports = new Set<string>();
-    const typeOnlyImportRegex = /\bimport\s+type\s+[\s\S]*?\s+from\s*["']([^"']+)["']/g;
-    for (const match of source.matchAll(typeOnlyImportRegex)) {
-      const importPath = match[1];
-      if (importPath && !imports.has(importPath)) typeImports.add(importPath);
-    }
 
-    const namedTypeOnlyImportRegex = /\bimport\s+{([^}]*)}\s+from\s*["']([^"']+)["']/g;
-    for (const match of source.matchAll(namedTypeOnlyImportRegex)) {
-      const namedImports = match[1]
-        ?.split(",")
-        .map((specifier) => specifier.trim())
-        .filter(Boolean);
-      const importPath = match[2];
-      if (importPath && namedImports?.every((specifier) => specifier.startsWith("type ")) && !imports.has(importPath)) {
+    const sourceFile = ts.createSourceFile(filePath, scanSource, ts.ScriptTarget.Latest, true);
+    for (const statement of sourceFile.statements) {
+      if (!ts.isImportDeclaration(statement)) continue;
+      if (!ts.isStringLiteral(statement.moduleSpecifier)) continue;
+
+      const importPath = statement.moduleSpecifier.text;
+      const namedBindings = statement.importClause?.namedBindings;
+      const isNamedTypeOnlyImport =
+        namedBindings &&
+        ts.isNamedImports(namedBindings) &&
+        namedBindings.elements.length > 0 &&
+        namedBindings.elements.every((element) => element.isTypeOnly);
+
+      if ((statement.importClause?.isTypeOnly || isNamedTypeOnlyImport) && !imports.has(importPath)) {
         typeImports.add(importPath);
       }
     }
@@ -188,6 +261,39 @@ export class TypeScriptDependencyScanner {
     return { imports: [...imports], typeImports: [...typeImports] };
   }
 
+  #extractCssPluginImports(source: string) {
+    const imports = new Set<string>();
+    const pluginRegex = /@plugin\s+(?:url\()?["']([^"')]+)["']\)?/g;
+    for (const match of source.matchAll(pluginRegex)) {
+      const importPath = match[1];
+      if (importPath) imports.add(importPath);
+    }
+    return [...imports];
+  }
+
+  #addNormalizedImports(deps: Set<string>, imports: string[], projectName: string) {
+    for (const importPath of imports) {
+      const dep = this.#normalizePackageImport(importPath, projectName);
+      if (dep) deps.add(dep);
+    }
+  }
+
+  #normalizePackageImport(importPath: string, projectName: string): string | null {
+    if (
+      importPath.startsWith(".") ||
+      importPath.startsWith("/") ||
+      importPath.startsWith("#") ||
+      importPath.startsWith("bun:") ||
+      builtinModuleSet.has(importPath)
+    )
+      return null;
+
+    const parts = importPath.split("/");
+    const packageName = importPath.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
+    if (!packageName || packageName === projectName || importPath.startsWith(`${projectName}/`)) return null;
+    return packageName;
+  }
+
   generateDependencyGraph(): string {
     let graph = "Dependency Graph:\n\n";
 

package/devkit/executors.ts

@@ -18,11 +18,10 @@ import {
   validatePageSourceFile,
   validateSubRoutePageKey,
 } from "akanjs/common";
-import chalk from "chalk";
-import { AkanAppConfig, AkanLibConfig, decreaseBuildNum, increaseBuildNum } from "./akanConfig";
-
 import { $ } from "bun";
+import chalk from "chalk";
 import ts from "typescript";
+import { AkanAppConfig, AkanLibConfig, decreaseBuildNum, increaseBuildNum } from "./akanConfig";
 import { FileSys } from "./fileSys";
 import { getDirname } from "./getDirname";
 import { Linter } from "./linter";
@@ -58,10 +57,7 @@ const parseEnvFile = (envPath: string): Record<string, string> => {
     if (separatorIndex <= 0) continue;
     const key = normalized.slice(0, separatorIndex).trim();
     let value = normalized.slice(separatorIndex + 1).trim();
-    if (
-      (value.startsWith('"') && value.endsWith('"')) ||
-      (value.startsWith("'") && value.endsWith("'"))
-    ) {
+    if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
       value = value.slice(1, -1);
     }
     env[key] = value;
@@ -1244,29 +1240,45 @@ export class PkgExecutor extends Executor {
     this.#scanInfo = scanInfo;
     return scanInfo;
   }
+  #toDependencyMap(
+    rootPackageJson: PackageJson,
+    dependencies: string[] = [],
+    devDependencies: string[] = [],
+  ): Pick<PackageJson, "dependencies" | "devDependencies"> {
+    const rootDeps = { ...rootPackageJson.dependencies, ...rootPackageJson.devDependencies };
+    const dependencyNames = [...new Set(dependencies)].sort();
+    const devDependencyNames = [...new Set(devDependencies)].filter((dep) => !dependencyNames.includes(dep)).sort();
+    const missingDeps = [...dependencyNames, ...devDependencyNames].filter((dep) => !rootDeps[dep]).sort();
+    if (missingDeps.length > 0)
+      throw new Error(`Missing dependency versions in root package.json: ${missingDeps.join(", ")}`);
+
+    return {
+      dependencies: Object.fromEntries(dependencyNames.map((dep) => [dep, rootDeps[dep]])),
+      devDependencies: Object.fromEntries(devDependencyNames.map((dep) => [dep, rootDeps[dep]])),
+    };
+  }
+  async updatePackageJsonDependencies(
+    dependencies: string[] = [],
+    devDependencies: string[] = [],
+  ): Promise<PackageJson> {
+    const [rootPackageJson, pkgJson] = await Promise.all([this.workspace.getPackageJson(), this.getPackageJson()]);
+    const dependencyMaps = this.#toDependencyMap(rootPackageJson, dependencies, devDependencies);
+    const newPkgJson = {
+      ...pkgJson,
+      ...dependencyMaps,
+    };
+    await this.writeJson("package.json", newPkgJson);
+    return newPkgJson;
+  }
   async generateDistPackageJson(dependencies: string[] = [], devDependencies: string[] = []): Promise<PackageJson> {
     const [rootPackageJson, pkgJson] = await Promise.all([this.workspace.getPackageJson(), this.getPackageJson()]);
-    const { dependencies: rootDependencies = {}, devDependencies: rootDevDependencies = {} } = rootPackageJson;
-    const rootDeps = { ...rootDependencies, ...rootDevDependencies };
+    const dependencyMaps = this.#toDependencyMap(rootPackageJson, dependencies, devDependencies);
     const distPkgJson: PackageJson = {
       ...pkgJson,
       type: "module",
       exports: { ...pkgJson.exports, ".": { import: "./index.ts", types: "./index.ts", default: "./index.ts" } },
       engines: { bun: ">=1.3.13" },
-      dependencies: Object.fromEntries(
-        dependencies.map((dep) => {
-          const rootVersion = rootDeps?.[dep];
-          if (!rootVersion) this.logger.warn(`Package ${dep} is not found in root package.json`);
-          return [dep, rootVersion];
-        }),
-      ),
-      devDependencies: Object.fromEntries(
-        devDependencies.map((dep) => {
-          const rootVersion = rootDeps?.[dep];
-          if (!rootVersion) this.logger.warn(`Package ${dep} is not found in root package.json`);
-          return [dep, rootVersion];
-        }),
-      ),
+      ...dependencyMaps,
     };
     await Promise.all([this.dist.writeJson("package.json", distPkgJson), this.writeJson("package.json", distPkgJson)]);
     return distPkgJson;

package/devkit/frontendBuild/cssCompiler.ts

@@ -8,6 +8,8 @@ import { CssImportResolver } from "./cssImportResolver";
 
 const SOURCE_EXTS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"] as const;
 const NON_SOURCE_EXT_RE = /\.(json|svg|png|jpe?g|webp|gif|avif|ico|woff2?|ttf|otf|mp3|mp4|wav)$/i;
+const NODE_MODULES_RE = /[\\/]node_modules[\\/]/;
+const AKANJS_NODE_MODULE_RE = /[\\/]node_modules[\\/]akanjs[\\/]/;
 
 interface CssDiscovery {
   cssPaths: string[];
@@ -88,7 +90,7 @@ export class CssCompiler {
 
     while (queue.length > 0) {
       const filePath = queue.shift();
-      if (!filePath || sourceFiles.has(filePath) || filePath.includes("node_modules")) continue;
+      if (!filePath || sourceFiles.has(filePath) || isIgnoredNodeModuleSource(filePath)) continue;
       sourceFiles.add(filePath);
 
       let content: string;
@@ -125,7 +127,7 @@ export class CssCompiler {
         }
         if (NON_SOURCE_EXT_RE.test(spec)) continue;
         const resolved = await this.#resolveSourceImport(spec, importerDir, resolvePackage);
-        if (!resolved || sourceFiles.has(resolved) || resolved.includes("node_modules")) continue;
+        if (!resolved || sourceFiles.has(resolved) || isIgnoredNodeModuleSource(resolved)) continue;
         queue.push(resolved);
       }
     }
@@ -221,7 +223,7 @@ export class CssCompiler {
     await Promise.all(
       dirs.map(async (dir) => {
         for await (const file of glob.scan({ cwd: dir, absolute: true })) {
-          if (file.includes("node_modules")) continue;
+          if (isIgnoredNodeModuleSource(file)) continue;
           files.add(file);
         }
       }),
@@ -271,6 +273,10 @@ function isSourceFile(filePath: string) {
   return SOURCE_EXTS.includes(path.extname(filePath) as (typeof SOURCE_EXTS)[number]);
 }
 
+export function isIgnoredNodeModuleSource(filePath: string): boolean {
+  return NODE_MODULES_RE.test(filePath) && !AKANJS_NODE_MODULE_RE.test(filePath);
+}
+
 function getPageKeyBasePath(pageKey: string, basePaths: string[]): string | null {
   const normalized = pageKey.split(path.sep).join("/").replace(/^\.\//, "");
   const segments = normalized.split("/");

package/devkit/incrementalBuilder/incrementalBuilder.proc.ts

@@ -308,7 +308,8 @@ class IncrementalBuilder {
   }
 
   #shouldRebuildCsr() {
-    return process.env.AKAN_DEV_CSR_REBUILD === "1";
+    
+    return true;
   }
 
   static async create() {

package/devkit/lint/no-deep-internal-import.grit

@@ -0,0 +1,25 @@
+engine biome(1.0)
+language js(typescript, jsx)
+
+or {
+  JsModuleSource() as $source where {
+    $source <: within JsImport(),
+    not $filename <: r".*\.(?:test|spec)\.tsx?",
+    $source <: r"\"@(?:apps|libs)/[^/]+/[^/]+/.+\"",
+    not $source <: r"\"@apps/[^/]+/env/env\.client\"",
+    register_diagnostic(
+      span = $source,
+      message = "@apps and @libs imports should only reference the first two path segments after the alias."
+    )
+  },
+  JsModuleSource() as $source where {
+    $source <: within JsImport(),
+    not $filename <: r".*\.(?:test|spec)\.tsx?",
+    $filename <: r".*apps/akasys/lib/projectBuild/[^/]+\.(?:constant|dictionary|document|service|signal|store)\.ts|.*apps/akasys/lib/projectBuild/[^/]+\.(?:Template|Unit|Util|View|Zone)\.tsx",
+    $source <: r"\"\.\./\.\./.*\"",
+    register_diagnostic(
+      span = $source,
+      message = "projectBuild module files should not import from two or more parent directories."
+    )
+  }
+}

package/devkit/lint/no-import-external-library.grit

@@ -11,6 +11,7 @@ JsModuleSource() as $source where {
     r"\"@apps/.*",
     r"\"@libs/.*",
     r"\"@pkgs/.*",
+    r"\"bun:test\"",
     r"\"react.*"
   },
   register_diagnostic(

package/devkit/mobile/mobileTarget.ts

@@ -16,23 +16,63 @@ export const getMobileTargets = async (app: App): Promise<ResolvedMobileTarget[]
   return Object.entries(config.mobile.targets).map(([name, target]) => ({ name, config: target }));
 };
 
+export const getMobileTargetChoices = async (app: App): Promise<string[]> => {
+  const config = await app.getConfig();
+  const targetNames = Object.keys(config.mobile.targets);
+  if (targetNames.length > 1) return targetNames;
+  const basePaths = [...config.basePaths];
+  if (basePaths.length > 1) return basePaths;
+  if (targetNames.length > 0) return targetNames;
+  return basePaths;
+};
+
+const resolveMobileTargetByBasePath = (
+  targets: ResolvedMobileTarget[],
+  basePath: string,
+): ResolvedMobileTarget | undefined => {
+  const normalizedBasePath = basePath.replace(/^\/+|\/+$/g, "");
+  const byBasePath = targets.find((target) => target.config.basePath?.replace(/^\/+|\/+$/g, "") === normalizedBasePath);
+  if (byBasePath) return byBasePath;
+  const [template] = targets;
+  if (!template) return undefined;
+  return {
+    name: template.name,
+    config: {
+      ...template.config,
+      basePath: normalizedBasePath,
+    },
+  };
+};
+
 export const resolveMobileTargets = async (
   app: App,
   selection: MobileTargetSelection,
 ): Promise<ResolvedMobileTarget[]> => {
+  const config = await app.getConfig();
   const targets = await getMobileTargets(app);
   if (targets.length === 0) throw new Error(`No mobile targets configured for ${app.name}`);
   if (!selection) {
-    if (targets.length === 1) return targets;
-    throw new Error(
-      `Multiple mobile targets found for ${app.name}. Pass --target <${targets.map((t) => t.name).join("|")}|all>.`,
-    );
+    const choices = await getMobileTargetChoices(app);
+    if (choices.length === 1) return resolveMobileTargets(app, choices[0]);
+    throw new Error(`Multiple mobile targets found for ${app.name}. Pass --target <${choices.join("|")}|all>.`);
+  }
+  if (selection === "all") {
+    if (Object.keys(config.mobile.targets).length > 1) return targets;
+    const basePaths = [...config.basePaths];
+    if (basePaths.length > 1) {
+      return basePaths.flatMap((basePath) => {
+        const resolved = resolveMobileTargetByBasePath(targets, basePath);
+        return resolved ? [resolved] : [];
+      });
+    }
+    return targets;
   }
-  if (selection === "all") return targets;
   const target = targets.find((candidate) => candidate.name === selection);
-  if (!target)
-    throw new Error(`Mobile target '${selection}' was not found. Available: ${targets.map((t) => t.name).join(", ")}`);
-  return [target];
+  if (target) return [target];
+  const basePathTarget = resolveMobileTargetByBasePath(targets, selection);
+  if (basePathTarget && config.basePaths.has(selection.replace(/^\/+|\/+$/g, ""))) return [basePathTarget];
+  const choices = await getMobileTargetChoices(app);
+  throw new Error(`Mobile target '${selection}' was not found. Available: ${choices.join(", ")}`);
 };
 
 export const resolveMobilePath = (target: AkanMobileTargetConfig, pathname: string) => {

package/devkit/scanInfo.ts

@@ -91,8 +91,11 @@ const moduleUiFileTypes = {
   scalar: new Set(["Template", "Unit"]),
 } satisfies Record<ModuleKind, Set<string>>;
 const testFilePattern = /\.(test|spec)\.(ts|tsx)$/;
+const rootSignalTestFilePattern = /^[A-Za-z][A-Za-z0-9_-]*\.signal\.(test|spec)\.(ts|tsx)$/;
 
 const isAllowedTestFile = (filename: string) => testFilePattern.test(filename);
+const isAllowedLibRootFile = (filename: string) =>
+  libRootAllowedFiles.has(filename) || rootSignalTestFilePattern.test(filename);
 const getScanPath = (exec: AppExecutor | LibExecutor, relativePath: string) =>
   path.posix.join(`${exec.type}s`, exec.name, relativePath.split(path.sep).join("/"));
 
@@ -117,7 +120,7 @@ async function assertScanConvention(exec: AppExecutor | LibExecutor, libRoot: {
   }
 
   libRoot.files
-    .filter((filename) => !libRootAllowedFiles.has(filename))
+    .filter((filename) => !isAllowedLibRootFile(filename))
     .forEach((filename) => {
       addViolation(path.join("lib", filename), "unsupported lib root file");
     });