npm - @akanjs/devkit - Versions diffs - 1.0.20 → 2.1.0-rc.1 - Mend

@akanjs/devkit 1.0.20 → 2.1.0-rc.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (195) hide show

package/README.ko.md +65 -0
package/README.md +62 -6
package/aiEditor.ts +304 -0
package/akanApp/akanApp.host.ts +393 -0
package/akanApp/index.ts +1 -0
package/akanConfig/akanConfig.test.ts +236 -0
package/akanConfig/akanConfig.ts +384 -0
package/akanConfig/index.ts +2 -0
package/akanConfig/types.ts +23 -0
package/applicationBuildReporter.ts +69 -0
package/applicationBuildRunner.ts +302 -0
package/applicationReleasePackager.ts +206 -0
package/artifact/implicitRootLayout.ts +155 -0
package/artifact/index.ts +1 -0
package/artifact/routeSeedIndex.test.ts +98 -0
package/artifact/routeSeedIndex.ts +130 -0
package/auth.ts +41 -0
package/builder.ts +164 -0
package/capacitor.base.config.ts +88 -0
package/capacitorApp.ts +440 -0
package/commandDecorators/argMeta.ts +102 -0
package/commandDecorators/command.ts +351 -0
package/commandDecorators/commandBuilder.ts +224 -0
package/commandDecorators/commandDecorators.test.ts +212 -0
package/commandDecorators/commandMeta.ts +7 -0
package/commandDecorators/dependencyBuilder.ts +100 -0
package/{esm/src/commandDecorators/helpFormatter.js → commandDecorators/helpFormatter.ts} +100 -47
package/{esm/src/commandDecorators/index.js → commandDecorators/index.ts} +4 -2
package/commandDecorators/targetMeta.ts +31 -0
package/commandDecorators/types.ts +10 -0
package/constants.ts +25 -0
package/createTunnel.ts +36 -0
package/dependencyScanner.ts +357 -0
package/devkitUtils.test.ts +259 -0
package/executors.test.ts +315 -0
package/executors.ts +1390 -0
package/{esm/src/extractDeps.js → extractDeps.ts} +26 -20
package/{esm/src/fileEditor.js → fileEditor.ts} +51 -32
package/fileSys.ts +39 -0
package/frontendBuild/allRoutesBuilder.ts +103 -0
package/frontendBuild/buildRouteClient.test.ts +190 -0
package/frontendBuild/clientBuildTypes.ts +114 -0
package/frontendBuild/clientEntriesBundler.ts +303 -0
package/frontendBuild/clientEntryDiscovery.ts +199 -0
package/frontendBuild/csrArtifactBuilder.ts +237 -0
package/frontendBuild/cssCompiler.ts +286 -0
package/frontendBuild/cssImportResolver.ts +116 -0
package/frontendBuild/fontOptimizer.ts +427 -0
package/frontendBuild/frontendBuild.test.ts +204 -0
package/frontendBuild/hmrChangeClassifier.ts +28 -0
package/frontendBuild/hmrWatcher.ts +102 -0
package/frontendBuild/index.ts +18 -0
package/frontendBuild/pagesBundleBuilder.ts +137 -0
package/frontendBuild/pagesEntrySourceGenerator.ts +37 -0
package/frontendBuild/precompressArtifacts.ts +59 -0
package/frontendBuild/routeClientBuilder.ts +290 -0
package/frontendBuild/routesManifestArtifactSerializer.ts +62 -0
package/frontendBuild/ssrBaseArtifactBuilder.ts +139 -0
package/frontendBuild/vendorSpecifiers.ts +16 -0
package/frontendBuild/watchRootResolver.ts +28 -0
package/getCredentials.ts +19 -0
package/getDirname.ts +3 -0
package/getModelFileData.ts +59 -0
package/getRelatedCnsts.ts +313 -0
package/guideline.ts +19 -0
package/incrementalBuilder/incrementalBuilder.host.test.ts +51 -0
package/incrementalBuilder/incrementalBuilder.host.ts +152 -0
package/incrementalBuilder/incrementalBuilder.proc.ts +331 -0
package/incrementalBuilder/index.ts +1 -0
package/{esm/src/index.js → index.ts} +28 -15
package/lint/no-deep-internal-import.grit +25 -0
package/lint/no-import-client-functions.grit +32 -0
package/lint/no-import-external-library.grit +21 -0
package/lint/no-js-private-class-method.grit +42 -0
package/lint/no-use-client-in-server.grit +7 -0
package/lint/non-scalar-props-restricted.grit +13 -0
package/linter.ts +271 -0
package/mobile/index.ts +1 -0
package/mobile/mobileTarget.test.ts +53 -0
package/mobile/mobileTarget.ts +88 -0
package/package.json +48 -31
package/prompter.ts +72 -0
package/scanInfo.ts +606 -0
package/selectModel.ts +11 -0
package/{esm/src/spinner.js → spinner.ts} +22 -28
package/{esm/src/capacitorApp.js → src/capacitorApp.ts} +82 -81
package/sshTunnel.ts +152 -0
package/{esm/src/streamAi.js → streamAi.ts} +18 -12
package/transforms/barrelAnalyzer.ts +278 -0
package/transforms/barrelImportsPlugin.ts +504 -0
package/transforms/externalizeFrameworkPlugin.ts +185 -0
package/transforms/index.ts +5 -0
package/transforms/rscUseClientTransform.ts +59 -0
package/transforms/transforms.test.ts +208 -0
package/transforms/useClientBundlePlugin.ts +47 -0
package/tsconfig.json +37 -0
package/typeChecker.ts +264 -0
package/types.ts +44 -0
package/ui/MultiScrollList.tsx +242 -0
package/ui/ScrollList.tsx +107 -0
package/ui/index.ts +2 -0
package/{esm/src/uploadRelease.js → uploadRelease.ts} +50 -34
package/{esm/src/useStdoutDimensions.js → useStdoutDimensions.ts} +5 -5
package/cjs/index.js +0 -21
package/cjs/src/aiEditor.js +0 -311
package/cjs/src/auth.js +0 -72
package/cjs/src/builder.js +0 -114
package/cjs/src/capacitorApp.js +0 -313
package/cjs/src/commandDecorators/argMeta.js +0 -88
package/cjs/src/commandDecorators/command.js +0 -324
package/cjs/src/commandDecorators/commandMeta.js +0 -30
package/cjs/src/commandDecorators/helpFormatter.js +0 -211
package/cjs/src/commandDecorators/index.js +0 -31
package/cjs/src/commandDecorators/targetMeta.js +0 -57
package/cjs/src/commandDecorators/types.js +0 -15
package/cjs/src/constants.js +0 -46
package/cjs/src/createTunnel.js +0 -49
package/cjs/src/dependencyScanner.js +0 -220
package/cjs/src/executors.js +0 -964
package/cjs/src/extractDeps.js +0 -103
package/cjs/src/fileEditor.js +0 -120
package/cjs/src/getCredentials.js +0 -44
package/cjs/src/getDirname.js +0 -38
package/cjs/src/getModelFileData.js +0 -66
package/cjs/src/getRelatedCnsts.js +0 -260
package/cjs/src/guideline.js +0 -15
package/cjs/src/index.js +0 -65
package/cjs/src/linter.js +0 -238
package/cjs/src/prompter.js +0 -85
package/cjs/src/scanInfo.js +0 -491
package/cjs/src/selectModel.js +0 -46
package/cjs/src/spinner.js +0 -93
package/cjs/src/streamAi.js +0 -62
package/cjs/src/typeChecker.js +0 -207
package/cjs/src/types.js +0 -15
package/cjs/src/uploadRelease.js +0 -112
package/cjs/src/useStdoutDimensions.js +0 -43
package/esm/index.js +0 -1
package/esm/src/aiEditor.js +0 -282
package/esm/src/auth.js +0 -42
package/esm/src/builder.js +0 -81
package/esm/src/commandDecorators/argMeta.js +0 -54
package/esm/src/commandDecorators/command.js +0 -290
package/esm/src/commandDecorators/commandMeta.js +0 -7
package/esm/src/commandDecorators/targetMeta.js +0 -33
package/esm/src/commandDecorators/types.js +0 -0
package/esm/src/constants.js +0 -17
package/esm/src/createTunnel.js +0 -26
package/esm/src/dependencyScanner.js +0 -187
package/esm/src/executors.js +0 -928
package/esm/src/getCredentials.js +0 -11
package/esm/src/getDirname.js +0 -5
package/esm/src/getModelFileData.js +0 -33
package/esm/src/getRelatedCnsts.js +0 -221
package/esm/src/guideline.js +0 -0
package/esm/src/linter.js +0 -205
package/esm/src/prompter.js +0 -51
package/esm/src/scanInfo.js +0 -455
package/esm/src/selectModel.js +0 -13
package/esm/src/typeChecker.js +0 -174
package/esm/src/types.js +0 -0
package/index.d.ts +0 -1
package/src/aiEditor.d.ts +0 -50
package/src/auth.d.ts +0 -9
package/src/builder.d.ts +0 -18
package/src/capacitorApp.d.ts +0 -39
package/src/commandDecorators/argMeta.d.ts +0 -67
package/src/commandDecorators/command.d.ts +0 -2
package/src/commandDecorators/commandMeta.d.ts +0 -2
package/src/commandDecorators/helpFormatter.d.ts +0 -3
package/src/commandDecorators/index.d.ts +0 -6
package/src/commandDecorators/targetMeta.d.ts +0 -19
package/src/commandDecorators/types.d.ts +0 -1
package/src/constants.d.ts +0 -26
package/src/createTunnel.d.ts +0 -8
package/src/dependencyScanner.d.ts +0 -23
package/src/executors.d.ts +0 -296
package/src/extractDeps.d.ts +0 -7
package/src/fileEditor.d.ts +0 -16
package/src/getCredentials.d.ts +0 -12
package/src/getDirname.d.ts +0 -1
package/src/getModelFileData.d.ts +0 -16
package/src/getRelatedCnsts.d.ts +0 -53
package/src/guideline.d.ts +0 -19
package/src/index.d.ts +0 -23
package/src/linter.d.ts +0 -109
package/src/prompter.d.ts +0 -14
package/src/scanInfo.d.ts +0 -82
package/src/selectModel.d.ts +0 -1
package/src/spinner.d.ts +0 -20
package/src/streamAi.d.ts +0 -6
package/src/typeChecker.d.ts +0 -52
package/src/types.d.ts +0 -31
package/src/uploadRelease.d.ts +0 -10
package/src/useStdoutDimensions.d.ts +0 -1

package/frontendBuild/csrArtifactBuilder.ts ADDED Viewed

@@ -0,0 +1,237 @@
+import { mkdir, rm, unlink } from "node:fs/promises";
+import path from "node:path";
+import type { BaseBuildArtifact } from "akanjs/server";
+import { resolveSsrPageEntriesForApp } from "../artifact/implicitRootLayout";
+import type { App } from "../commandDecorators";
+import { PagesEntrySourceGenerator } from "./pagesEntrySourceGenerator";
+export interface BuildCsrArtifactResult {
+  outputDir: string;
+}
+export class CsrArtifactBuilder {
+  #app: App;
+  #command: "build" | "start";
+  #lang: string;
+  constructor(app: App, command: "build" | "start" = "start", lang = "en") {
+    this.#app = app;
+    this.#command = command;
+    this.#lang = lang;
+  }
+  async build(): Promise<BuildCsrArtifactResult | null> {
+    const pageKeys = await this.#app.getPageKeys();
+    if (pageKeys.length === 0) {
+      this.#app.log(`[cli] no route files under ${this.#app.cwdPath}/page — skipping CSR build`);
+      return null;
+    }
+    const pageEntries = await resolveSsrPageEntriesForApp(this.#app, pageKeys);
+    const akanConfig = await this.#app.getConfig();
+    const artifact = await this.#loadCsrArtifact();
+    const csrBasePaths = [...akanConfig.basePaths];
+    const htmlEntries = csrBasePaths.length > 0 ? csrBasePaths : ["index"];
+    await rm(this.#outputDir, { recursive: true, force: true });
+    await mkdir(path.join(this.#app.cwdPath, ".akan/generated/csr"), { recursive: true });
+    const generatedHtmlFiles = Object.fromEntries(htmlEntries.map((basePath) => this.#createHtmlFile(basePath)));
+    const result = await Bun.build({
+      target: "browser",
+      entrypoints: Object.keys(generatedHtmlFiles),
+      files: {
+        ...generatedHtmlFiles,
+        [`${this.#app.cwdPath}/.akan/generated/csr/csr.tsx`]: `
+import { bootCsr } from "akanjs/webkit";
+${PagesEntrySourceGenerator.generateStatic(pageEntries)}
+void bootCsr(pages);
+  `,
+      },
+      root: `${this.#app.cwdPath}/.akan/generated/csr`,
+      outdir: this.#outputDir,
+      splitting: false,
+      minify: true,
+      env: "AKAN_PUBLIC_*",
+      define: this.#define(),
+      optimizeImports: akanConfig.optimizeImports,
+    });
+    if (!result.success) {
+      const logs = result.logs.map((log) => log.message).join("\n");
+      throw new Error(`[csr-build] failed${logs ? `\n${logs}` : ""}`);
+    }
+    await this.#inlineCsrArtifacts(artifact.cssAssets ?? {});
+    this.#app.verbose(`[csr-build] output -> ${this.#outputDir}`);
+    return { outputDir: this.#outputDir };
+  }
+  get #outputDir(): string {
+    return path.join(
+      this.#command === "build" ? this.#app.dist.cwdPath : this.#app.cwdPath,
+      this.#command === "build" ? "csr" : ".akan/artifact/csr",
+    );
+  }
+  #define(): Record<string, string> {
+    const nodeEnv = this.#command === "build" ? "production" : (process.env.NODE_ENV ?? "development");
+    return {
+      "process.env.NODE_ENV": JSON.stringify(nodeEnv),
+      "process.env.AKAN_PUBLIC_RENDER_ENV": JSON.stringify("csr"),
+      ...Object.fromEntries(
+        Object.entries(this.#app.getPublicEnv()).map(([key, value]) => [`process.env.${key}`, JSON.stringify(value)]),
+      ),
+    };
+  }
+  #createHtmlFile(basePath: string): readonly [string, string] {
+    const filename = `${basePath}.html`;
+    return [
+      `${this.#app.cwdPath}/.akan/generated/csr/${filename}`,
+      `<!doctype html>
+<html lang="${this.#lang}">
+  <head>
+    <meta charset="utf-8" />
+    <title>${this.#app.name}</title>
+    <base href="/" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="./csr.tsx"></script>
+  </body>
+</html>
+  `,
+    ] as const;
+  }
+  async #loadCsrArtifact(): Promise<Pick<BaseBuildArtifact, "cssAssets">> {
+    const artifactDir = path.join(
+      this.#command === "build" ? this.#app.dist.cwdPath : this.#app.cwdPath,
+      ".akan/artifact",
+    );
+    const artifactFile = Bun.file(path.join(artifactDir, "base-artifact.json"));
+    if (!(await artifactFile.exists())) return { cssAssets: {} };
+    const artifact = (await artifactFile.json()) as Pick<BaseBuildArtifact, "cssAssets">;
+    return { cssAssets: artifact.cssAssets ?? {} };
+  }
+  async #inlineCsrArtifacts(cssAssets: Record<string, { cssUrl: string; cssRelPath: string }>): Promise<void> {
+    const jsFiles = new Set<string>();
+    const cssFiles = new Set<string>();
+    for (const htmlPath of await this.#htmlOutputPaths()) {
+      const htmlFile = Bun.file(htmlPath);
+      if (!(await htmlFile.exists())) continue;
+      const basePath = path.basename(htmlPath, ".html") === "index" ? "" : path.basename(htmlPath, ".html");
+      const inlined = await this.#inlineHtmlAssets(await htmlFile.text(), htmlPath, cssAssets[basePath]);
+      for (const filePath of inlined.jsFiles) jsFiles.add(filePath);
+      for (const filePath of inlined.cssFiles) cssFiles.add(filePath);
+      await Bun.write(htmlPath, inlined.html);
+    }
+    for (const filePath of jsFiles) await unlink(filePath).catch(() => undefined);
+    for (const filePath of cssFiles) await unlink(filePath).catch(() => undefined);
+    const remainingJs = await this.#listOutputFiles((filePath) => filePath.endsWith(".js"));
+    const remainingCss = await this.#listOutputFiles((filePath) => filePath.endsWith(".css"));
+    const remainingAssets = [...remainingJs, ...remainingCss];
+    if (remainingAssets.length > 0) {
+      throw new Error(`[csr-build] expected single-file HTML, but CSR assets remain:\n${remainingAssets.join("\n")}`);
+    }
+  }
+  async #inlineHtmlAssets(
+    html: string,
+    htmlPath: string,
+    cssAsset?: { cssUrl: string; cssRelPath: string },
+  ): Promise<{ html: string; jsFiles: string[]; cssFiles: string[] }> {
+    const jsFiles: string[] = [];
+    const cssFiles = CsrArtifactBuilder.collectStylesheetHrefs(html).map((href) =>
+      CsrArtifactBuilder.resolveHtmlAssetPath(htmlPath, href),
+    );
+    let next = CsrArtifactBuilder.stripBundledStylesheetLinks(html);
+    next = await CsrArtifactBuilder.replaceModuleScriptSrc(next, async (src) => {
+      const jsPath = CsrArtifactBuilder.resolveHtmlAssetPath(htmlPath, src);
+      jsFiles.push(jsPath);
+      return await Bun.file(jsPath).text();
+    });
+    if (cssAsset) {
+      const cssPath = path.join(
+        this.#command === "build" ? this.#app.dist.cwdPath : this.#app.cwdPath,
+        ".akan/artifact",
+        cssAsset.cssRelPath,
+      );
+      const css = await Bun.file(cssPath).text();
+      const style = CsrArtifactBuilder.createInlineStyle(css);
+      if (!next.includes(style)) next = CsrArtifactBuilder.injectBeforeHeadEnd(next, style);
+    }
+    return { html: next, jsFiles, cssFiles };
+  }
+  async #htmlOutputPaths(): Promise<string[]> {
+    return await this.#listOutputFiles((filePath) => filePath.endsWith(".html"));
+  }
+  async #listOutputFiles(predicate: (filePath: string) => boolean): Promise<string[]> {
+    const glob = new Bun.Glob("**/*");
+    const files: string[] = [];
+    for await (const filePath of glob.scan({ cwd: this.#outputDir, absolute: true })) {
+      if (predicate(filePath)) files.push(filePath);
+    }
+    return files.sort();
+  }
+  static injectBeforeHeadEnd(html: string, snippet: string): string {
+    const matches = [...html.matchAll(/<\/head\s*>/gi)];
+    const bodyStart = html.search(/<body(?:\s|>)/i);
+    const headEnd = matches
+      .filter((match) => match.index !== undefined && (bodyStart === -1 || match.index < bodyStart))
+      .at(-1);
+    if (!headEnd || headEnd.index === undefined) return `${snippet}\n${html}`;
+    return `${html.slice(0, headEnd.index)}${snippet}\n${html.slice(headEnd.index)}`;
+  }
+  static stripBundledStylesheetLinks(html: string): string {
+    return html.replace(/<link\b(?=[^>]*\brel=["']stylesheet["'])[^>]*>\s*/gi, "");
+  }
+  static collectStylesheetHrefs(html: string): string[] {
+    const linkRe = /<link\b(?=[^>]*\brel=["']stylesheet["'])(?=[^>]*\bhref=["']([^"']+)["'])[^>]*>/gi;
+    return [...html.matchAll(linkRe)].map((match) => match[1]).filter((href): href is string => !!href);
+  }
+  static createInlineStyle(css: string): string {
+    return `<style data-akan-css="active">\n${css.replace(/<\/style/gi, "<\\/style")}\n</style>`;
+  }
+  static async replaceModuleScriptSrc(
+    html: string,
+    loadScript: (src: string) => Promise<string> | string,
+  ): Promise<string> {
+    const scriptRe = /<script\b(?=[^>]*\btype=["']module["'])(?=[^>]*\bsrc=["']([^"']+)["'])[^>]*>\s*<\/script>/gi;
+    let result = "";
+    let lastIndex = 0;
+    let matched = false;
+    for (const match of html.matchAll(scriptRe)) {
+      const full = match[0];
+      const src = match[1];
+      if (match.index === undefined || !src) continue;
+      matched = true;
+      result += html.slice(lastIndex, match.index);
+      result += `<script type="module">\n${CsrArtifactBuilder.escapeInlineScript(await loadScript(src))}\n</script>`;
+      lastIndex = match.index + full.length;
+    }
+    if (!matched) return html;
+    return result + html.slice(lastIndex);
+  }
+  static escapeInlineScript(source: string): string {
+    return source.replace(/<\/script/gi, "<\\/script");
+  }
+  static resolveHtmlAssetPath(htmlPath: string, src: string): string {
+    if (/^[a-z][a-z0-9+.-]*:/i.test(src) || src.startsWith("//")) {
+      throw new Error(`[csr-build] cannot inline external script: ${src}`);
+    }
+    const normalized = src.startsWith("/") ? src.slice(1) : src;
+    return path.resolve(path.dirname(htmlPath), normalized);
+  }
+}

package/frontendBuild/cssCompiler.ts ADDED Viewed

@@ -0,0 +1,286 @@
+import path from "node:path";
+import { Logger } from "akanjs/common";
+import { compile } from "tailwindcss";
+import type { App } from "../commandDecorators";
+import { BarrelAnalyzer } from "../transforms/barrelAnalyzer";
+import { createTsconfigPackageResolver, rewriteBarrelImports } from "../transforms/barrelImportsPlugin";
+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[];
+  sourcePaths: string[];
+}
+export class CssCompiler {
+  #logger = new Logger("CssCompiler");
+  #transpiler = new Bun.Transpiler({ loader: "tsx" });
+  #app: App;
+  #cssImportResolver: CssImportResolver | null = null;
+  constructor(app: App) {
+    this.#app = app;
+  }
+  #cssText: string | null = null;
+  #cssTextByBasePath: Record<string, string> | null = null;
+  async getCss({ refresh }: { refresh?: boolean } = {}) {
+    if (this.#cssText !== null && !refresh) return this.#cssText;
+    const { cssPaths, sourcePaths } = await this.discoverCssAndSources({ refresh });
+    this.#cssText = await this.compileCss(cssPaths, sourcePaths);
+    return this.#cssText;
+  }
+  async getCssByBasePath({ refresh }: { refresh?: boolean } = {}): Promise<Record<string, string>> {
+    if (this.#cssTextByBasePath !== null && !refresh) return this.#cssTextByBasePath;
+    const akanConfig = await this.#app.getConfig({ refresh });
+    const pageKeys = await this.#app.getPageKeys({ refresh });
+    const basePaths = [...akanConfig.basePaths];
+    const rootPageKeys = pageKeys.filter((pageKey) => getPageKeyBasePath(pageKey, basePaths) === null);
+    const cssEntries = await Promise.all([
+      (async () => {
+        if (rootPageKeys.length === 0) return ["", ""] as const;
+        const started = Date.now();
+        const { cssPaths, sourcePaths } = await this.discoverCssAndSources({ refresh, pageKeys: rootPageKeys });
+        const css = await this.compileCss(cssPaths, sourcePaths);
+        this.#logger.verbose(
+          `css base=root paths=${cssPaths.length} sources=${sourcePaths.length} in ${Date.now() - started}ms`,
+        );
+        return ["", css] as const;
+      })(),
+      ...basePaths.map(async (basePath) => {
+        const basePathPageKeys = pageKeys.filter((pageKey) => getPageKeyBasePath(pageKey, basePaths) === basePath);
+        if (basePathPageKeys.length === 0) return [basePath, ""] as const;
+        const started = Date.now();
+        const { cssPaths, sourcePaths } = await this.discoverCssAndSources({ refresh, pageKeys: basePathPageKeys });
+        const css = await this.compileCss(cssPaths, sourcePaths);
+        this.#logger.verbose(
+          `css base=${basePath} paths=${cssPaths.length} sources=${sourcePaths.length} in ${Date.now() - started}ms`,
+        );
+        return [basePath, css] as const;
+      }),
+    ]);
+    this.#cssTextByBasePath = Object.fromEntries(cssEntries);
+    return this.#cssTextByBasePath;
+  }
+  async discoverCss({ refresh }: { refresh?: boolean } = {}): Promise<string[]> {
+    const { cssPaths } = await this.discoverCssAndSources({ refresh });
+    return cssPaths;
+  }
+  async discoverCssAndSources({
+    refresh,
+    pageKeys,
+  }: {
+    refresh?: boolean;
+    pageKeys?: string[];
+  } = {}): Promise<CssDiscovery> {
+    pageKeys ??= await this.#app.getPageKeys({ refresh });
+    const seeds = pageKeys.map((key) => path.resolve(this.#app.cwdPath, "page", key));
+    const cssFiles = new Set<string>();
+    const sourceFiles = new Set<string>();
+    const queue = [...seeds];
+    const resolvePackage = await createTsconfigPackageResolver(this.#app);
+    const analyzer = new BarrelAnalyzer({ resolvePackage });
+    const akanConfig = await this.#app.getConfig({ refresh });
+    while (queue.length > 0) {
+      const filePath = queue.shift();
+      if (!filePath || sourceFiles.has(filePath) || isIgnoredNodeModuleSource(filePath)) continue;
+      sourceFiles.add(filePath);
+      let content: string;
+      try {
+        content = await Bun.file(filePath).text();
+      } catch {
+        continue;
+      }
+      let source = content;
+      if (akanConfig.barrelImports.length > 0) {
+        try {
+          const rewritten = await rewriteBarrelImports(content, akanConfig.barrelImports, analyzer);
+          if (rewritten !== null) source = rewritten;
+        } catch {
+          // best-effort: unresolved barrel rewrites should not stop CSS discovery
+        }
+      }
+      let imports: Bun.Import[];
+      try {
+        imports = this.#transpiler.scanImports(source);
+      } catch {
+        continue;
+      }
+      const importerDir = path.dirname(filePath);
+      for (const imp of imports) {
+        const spec = imp.path;
+        if (!spec) continue;
+        if (spec.endsWith(".css")) {
+          const cssPath = await this.#resolveCssImport(spec, importerDir);
+          cssFiles.add(cssPath);
+          continue;
+        }
+        if (NON_SOURCE_EXT_RE.test(spec)) continue;
+        const resolved = await this.#resolveSourceImport(spec, importerDir, resolvePackage);
+        if (!resolved || sourceFiles.has(resolved) || isIgnoredNodeModuleSource(resolved)) continue;
+        queue.push(resolved);
+      }
+    }
+    return { cssPaths: [...cssFiles], sourcePaths: [...sourceFiles] };
+  }
+  async compileCss(cssPaths: string[], sourcePaths: string[]): Promise<string> {
+    if (cssPaths.length === 0) return "";
+    const compileStarted = Date.now();
+    const compilers = await Promise.all(
+      cssPaths.map(async (cssPath) => {
+        const css = await Bun.file(cssPath).text();
+        const base = path.dirname(cssPath);
+        const compiler = await compile(css, {
+          base,
+          loadStylesheet: (id, fromBase) => this.#loadStylesheet(id, fromBase),
+          loadModule: (id, fromBase) => this.#loadModule(id, fromBase),
+        });
+        return { cssPath, compiler };
+      }),
+    );
+    const sourceDirs = new Set<string>();
+    for (const entry of compilers) {
+      if (!entry) continue;
+      for (const s of entry.compiler.sources as { base: string }[]) sourceDirs.add(s.base);
+    }
+    const scanStarted = Date.now();
+    const candidates = await this.#scanCandidates(sourcePaths, [...sourceDirs]);
+    this.#logger.verbose(
+      `css candidates scanned count=${candidates.length} sources=${sourcePaths.length} dirs=${sourceDirs.size} in ${Date.now() - scanStarted}ms`,
+    );
+    const parts: string[] = [];
+    for (const entry of compilers) {
+      if (!entry) continue;
+      parts.push(entry.compiler.build(candidates));
+    }
+    this.#logger.verbose(
+      `css compiled paths=${cssPaths.length} candidates=${candidates.length} in ${Date.now() - compileStarted}ms`,
+    );
+    return parts.join("\n");
+  }
+  async #loadStylesheet(id: string, fromBase: string) {
+    const p = await this.#resolveCssImport(id, fromBase);
+    const content = await Bun.file(p).text();
+    return { path: p, base: path.dirname(p), content };
+  }
+  async #resolveCssImport(id: string, fromBase: string): Promise<string> {
+    if (id.startsWith(".") || id.startsWith("/")) return path.resolve(fromBase, id);
+    const resolver = await this.#getCssImportResolver();
+    const resolved = await resolver.resolve(id, fromBase);
+    if (resolved) return resolved;
+    throw new Error(`[css] failed to resolve stylesheet import "${id}" from ${fromBase}`);
+  }
+  async #getCssImportResolver() {
+    if (this.#cssImportResolver) return this.#cssImportResolver;
+    this.#cssImportResolver = await CssImportResolver.create(this.#app);
+    return this.#cssImportResolver;
+  }
+  async #loadModule(id: string, fromBase: string) {
+    const p = require.resolve(id, { paths: [fromBase] });
+    const mod = await import(p);
+    return { path: p, base: path.dirname(p), module: mod.default ?? mod };
+  }
+  async #resolveSourceImport(
+    id: string,
+    fromBase: string,
+    resolvePackage: Awaited<ReturnType<typeof createTsconfigPackageResolver>>,
+  ): Promise<string | null> {
+    if (id.startsWith(".") || id.startsWith("/")) {
+      const abs = id.startsWith("/") ? id : path.resolve(fromBase, id);
+      return resolveSourceFileCandidate(abs);
+    }
+    const pkg = await resolvePackage(id);
+    if (pkg) return pkg.entryFile;
+    for (const resolve of [() => resolveSourceWithBun(id, fromBase), () => resolveSourceWithRequire(id, fromBase)]) {
+      const resolved = await resolve();
+      if (resolved) return resolved;
+    }
+    return null;
+  }
+  async #scanCandidates(sourcePaths: string[], dirs: string[]): Promise<string[]> {
+    const CANDIDATE_RE = /-?[\w@][\w:/.-]*(?:\[[^\]]+\][\w:/.-]*)*/g;
+    const candidates = new Set<string>();
+    const glob = new Bun.Glob("**/*.{tsx,ts,jsx,js,html}");
+    const files = new Set<string>(sourcePaths);
+    await Promise.all(
+      dirs.map(async (dir) => {
+        for await (const file of glob.scan({ cwd: dir, absolute: true })) {
+          if (isIgnoredNodeModuleSource(file)) continue;
+          files.add(file);
+        }
+      }),
+    );
+    await Promise.all(
+      [...files].map(async (file) => {
+        const content = await Bun.file(file).text();
+        for (const m of content.matchAll(CANDIDATE_RE)) candidates.add(m[0]);
+      }),
+    );
+    return [...candidates];
+  }
+}
+async function resolveSourceFileCandidate(absPathNoExt: string): Promise<string | null> {
+  if (await Bun.file(absPathNoExt).exists()) return isSourceFile(absPathNoExt) ? absPathNoExt : null;
+  for (const ext of SOURCE_EXTS) {
+    const filePath = `${absPathNoExt}${ext}`;
+    if (await Bun.file(filePath).exists()) return filePath;
+  }
+  for (const ext of SOURCE_EXTS) {
+    const filePath = path.join(absPathNoExt, `index${ext}`);
+    if (await Bun.file(filePath).exists()) return filePath;
+  }
+  return null;
+}
+function resolveSourceWithBun(id: string, fromBase: string): string | null {
+  try {
+    const resolved = Bun.resolveSync(id, fromBase);
+    return isSourceFile(resolved) ? resolved : null;
+  } catch {
+    return null;
+  }
+}
+function resolveSourceWithRequire(id: string, fromBase: string): string | null {
+  try {
+    const resolved = require.resolve(id, { paths: [fromBase] });
+    return isSourceFile(resolved) ? resolved : null;
+  } catch {
+    return null;
+  }
+}
+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("/");
+  const firstPublicSegment = segments.find((segment) => segment !== "[lang]" && !/^\(.+\)$/.test(segment));
+  return firstPublicSegment && basePaths.includes(firstPublicSegment) ? firstPublicSegment : null;
+}

package/frontendBuild/cssImportResolver.ts ADDED Viewed

@@ -0,0 +1,116 @@
+import path from "node:path";
+import type { App } from "../commandDecorators";
+const CSS_IMPORT_EXTS = ["", ".css", "/styles.css", "/index.css"] as const;
+export class CssImportResolver {
+  #workspaceRoot: string;
+  #paths: Record<string, string[]>;
+  #wildcardEntries: { prefix: string; replacements: string[] }[];
+  constructor(workspaceRoot: string, paths: Record<string, string[]> = {}) {
+    this.#workspaceRoot = workspaceRoot;
+    this.#paths = paths;
+    this.#wildcardEntries = Object.entries(paths)
+      .filter(([key]) => key.endsWith("/*"))
+      .map(([key, replacements]) => ({ prefix: key.slice(0, -1), replacements }))
+      .sort((a, b) => b.prefix.length - a.prefix.length);
+  }
+  static async create(app: App): Promise<CssImportResolver> {
+    const tsconfig = await app.getTsConfig();
+    return new CssImportResolver(app.workspace.workspaceRoot, tsconfig.compilerOptions.paths ?? {});
+  }
+  async resolve(id: string, fromBase: string): Promise<string | null> {
+    for (const resolve of [
+      () => this.#resolveWithBun(id, fromBase),
+      () => this.#resolveWithRequire(id, fromBase),
+      () => this.#resolveWithTsconfig(id),
+      () => this.#resolvePackageStyle(id, fromBase),
+    ]) {
+      const resolved = await resolve();
+      if (resolved) return resolved;
+    }
+    return null;
+  }
+  #resolveWithBun(id: string, fromBase: string): string | null {
+    try {
+      const resolved = Bun.resolveSync(id, fromBase);
+      return CssImportResolver.isCssFile(resolved) ? resolved : null;
+    } catch {
+      return null;
+    }
+  }
+  #resolveWithRequire(id: string, fromBase: string): string | null {
+    try {
+      const resolved = require.resolve(id, { paths: [fromBase] });
+      return CssImportResolver.isCssFile(resolved) ? resolved : null;
+    } catch {
+      return null;
+    }
+  }
+  async #resolveWithTsconfig(id: string): Promise<string | null> {
+    const exact = this.#paths[id];
+    if (exact) {
+      for (const repl of exact) {
+        const resolved = await this.#firstExisting(path.resolve(this.#workspaceRoot, repl));
+        if (resolved) return resolved;
+      }
+    }
+    for (const { prefix, replacements } of this.#wildcardEntries) {
+      if (!id.startsWith(prefix)) continue;
+      const suffix = id.slice(prefix.length);
+      for (const repl of replacements) {
+        const replPath = repl.endsWith("/*") ? repl.slice(0, -1) : repl;
+        const resolved = await this.#firstExisting(path.resolve(this.#workspaceRoot, replPath + suffix));
+        if (resolved) return resolved;
+      }
+    }
+    return null;
+  }
+  async #resolvePackageStyle(id: string, fromBase: string): Promise<string | null> {
+    const pkgName = CssImportResolver.getPackageName(id);
+    if (!pkgName) return null;
+    try {
+      const pkgPath = require.resolve(`${pkgName}/package.json`, { paths: [fromBase] });
+      const pkgDir = path.dirname(pkgPath);
+      const pkg = await Bun.file(pkgPath).json();
+      const subpath = id === pkgName ? "." : `.${id.slice(pkgName.length)}`;
+      const exportValue = pkg.exports?.[subpath];
+      const styleEntry =
+        (typeof exportValue === "string"
+          ? exportValue
+          : exportValue?.style || exportValue?.import || exportValue?.default) ||
+        pkg.exports?.["."]?.style ||
+        pkg.style ||
+        "index.css";
+      return await this.#firstExisting(path.resolve(pkgDir, styleEntry));
+    } catch {
+      return null;
+    }
+  }
+  async #firstExisting(basePath: string): Promise<string | null> {
+    for (const suffix of CSS_IMPORT_EXTS) {
+      const candidate = `${basePath}${suffix}`;
+      if (await Bun.file(candidate).exists()) return candidate;
+    }
+    return null;
+  }
+  static getPackageName(id: string): string | null {
+    const parts = id.split("/");
+    if (id.startsWith("@")) return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : null;
+    return parts[0] ?? null;
+  }
+  static isCssFile(filePath: string): boolean {
+    return path.extname(filePath) === ".css";
+  }
+}