@akanjs/cli 3.1.0-rc.0 → 3.1.0-rc.10

package/index-62md4dwy.js

@@ -0,0 +1,260 @@
+// @bun
+// pkgs/@akanjs/devkit/frontendBuild/cssBlockParser.ts
+class CssBlockParser {
+  #css;
+  #stack = [{ kind: "block", prelude: "", atRule: null, nodes: [] }];
+  #pendingParts = [];
+  #segmentStart = 0;
+  #parenDepth = 0;
+  constructor(css) {
+    this.#css = css;
+  }
+  static parse(css) {
+    return new CssBlockParser(css).#run();
+  }
+  static walk(root, context, visit) {
+    const stack = [{ nodes: root.nodes, idx: 0, context }];
+    while (stack.length > 0) {
+      const frame = stack[stack.length - 1];
+      const node = frame.nodes[frame.idx];
+      if (!node) {
+        stack.pop();
+        continue;
+      }
+      frame.idx += 1;
+      const childContext = visit(node, frame.context);
+      if (node.kind === "block" && childContext !== null)
+        stack.push({ nodes: node.nodes, idx: 0, context: childContext });
+    }
+  }
+  #run() {
+    const css = this.#css;
+    let idx = 0;
+    while (idx < css.length) {
+      const char = css[idx];
+      if (char === "/" && css[idx + 1] === "*") {
+        this.#pendingParts.push(css.slice(this.#segmentStart, idx));
+        const end = css.indexOf("*/", idx + 2);
+        idx = end === -1 ? css.length : end + 2;
+        this.#segmentStart = idx;
+        continue;
+      }
+      if (char === "\\") {
+        idx += 2;
+        continue;
+      }
+      if (char === '"' || char === "'") {
+        idx = this.#skipString(idx);
+        continue;
+      }
+      if (char === "(")
+        this.#parenDepth += 1;
+      else if (char === ")")
+        this.#parenDepth = Math.max(0, this.#parenDepth - 1);
+      else if (char === "{")
+        this.#openBlock(idx);
+      else if (char === "}")
+        this.#closeBlock(idx);
+      else if (char === ";" && this.#parenDepth === 0)
+        this.#endStatement(idx);
+      idx += 1;
+    }
+    this.#endStatement(css.length);
+    return this.#stack[0];
+  }
+  get #current() {
+    return this.#stack[this.#stack.length - 1];
+  }
+  #skipString(start) {
+    const css = this.#css;
+    const quote = css[start];
+    let idx = start + 1;
+    while (idx < css.length) {
+      const char = css[idx];
+      if (char === "\\")
+        idx += 2;
+      else if (char === quote)
+        return idx + 1;
+      else if (char === `
+`)
+        return idx;
+      else
+        idx += 1;
+    }
+    return css.length;
+  }
+  #takeSegment(end) {
+    const text = this.#pendingParts.join("") + this.#css.slice(this.#segmentStart, end);
+    this.#pendingParts = [];
+    this.#segmentStart = end + 1;
+    return text.trim();
+  }
+  #openBlock(idx) {
+    const prelude = this.#takeSegment(idx);
+    const block = { kind: "block", prelude, atRule: CssBlockParser.#atRuleOf(prelude), nodes: [] };
+    this.#current.nodes.push(block);
+    this.#stack.push(block);
+    this.#parenDepth = 0;
+  }
+  #closeBlock(idx) {
+    this.#endStatement(idx);
+    if (this.#stack.length > 1)
+      this.#stack.pop();
+    this.#parenDepth = 0;
+  }
+  #endStatement(idx) {
+    const text = this.#takeSegment(idx);
+    if (!text || text.startsWith("@"))
+      return;
+    const colon = text.indexOf(":");
+    if (colon <= 0)
+      return;
+    const property = text.slice(0, colon).trim();
+    if (!/^[\w-]+$/.test(property))
+      return;
+    this.#current.nodes.push({ kind: "declaration", property, value: text.slice(colon + 1).trim() });
+  }
+  static #atRuleOf(prelude) {
+    return prelude.match(/^@[\w-]+/)?.[0].toLowerCase() ?? null;
+  }
+}
+
+// pkgs/@akanjs/devkit/frontendBuild/styleContract.ts
+var countBlocking = (violations) => violations.theme.length;
+var formatStyleContract = (violations) => violations.theme.flatMap((theme) => [
+  `  [error] contrast  ${theme.scope}  ${theme.pair} = ${theme.ratio}:1 (min ${theme.threshold}:1)`,
+  `      \u2192 ${theme.suggestion}`
+]).join(`
+`);
+
+// pkgs/@akanjs/devkit/frontendBuild/themeValidator.ts
+var PAIRS = [
+  { base: "background", fg: "foreground", threshold: 4.5 },
+  { base: "primary", fg: "primary-foreground", threshold: 4.5 },
+  { base: "secondary", fg: "secondary-foreground", threshold: 4.5 },
+  { base: "accent", fg: "accent-foreground", threshold: 4.5 },
+  { base: "neutral", fg: "neutral-foreground", threshold: 4.5 },
+  { base: "card", fg: "card-foreground", threshold: 4.5 },
+  { base: "popover", fg: "popover-foreground", threshold: 4.5 },
+  { base: "muted", fg: "muted-foreground", threshold: 3 },
+  { base: "info", fg: "info-foreground", threshold: 3 },
+  { base: "success", fg: "success-foreground", threshold: 3 },
+  { base: "warning", fg: "warning-foreground", threshold: 3 },
+  { base: "destructive", fg: "destructive-foreground", threshold: 3 },
+  { base: "open", fg: "open-foreground", threshold: 3 }
+];
+var THEME_SCOPES = new Set([":root", '[data-theme="dark"]', '[data-theme="light"]']);
+var CONDITIONAL_AT_RULES = new Set(["@media", "@supports", "@container"]);
+
+class ThemeValidator {
+  validate(css) {
+    const tokensByScope = ThemeValidator.parseThemeTokens(css);
+    const violations = [];
+    for (const [scope, tokens] of Object.entries(tokensByScope)) {
+      const underlying = THEME_SCOPES.has(scope) ? null : [...THEME_SCOPES].find((name) => scope.endsWith(` ${name}`));
+      const effective = underlying ? ThemeValidator.#overlayPairs(tokensByScope[underlying] ?? {}, tokens) : tokens;
+      violations.push(...this.validateScope(effective, scope));
+    }
+    return violations;
+  }
+  validateScope(tokens, scope) {
+    const violations = [];
+    for (const { base, fg, threshold } of PAIRS) {
+      const bg = tokens[base];
+      const front = tokens[fg];
+      if (!bg || !front)
+        continue;
+      const bgRgb = ThemeValidator.parseHex(bg);
+      const fgRgb = ThemeValidator.parseHex(front);
+      if (!bgRgb || !fgRgb)
+        continue;
+      const ratio = ThemeValidator.contrastRatio(bgRgb, fgRgb);
+      if (ratio >= threshold)
+        continue;
+      violations.push({
+        scope,
+        pair: `${base} / ${fg}`,
+        background: bg,
+        foreground: front,
+        ratio: Math.round(ratio * 100) / 100,
+        threshold,
+        suggestion: `In ${scope}, --${base} (${bg}) against --${fg} (${front}) is ${ratio.toFixed(2)}:1, under the ${threshold}:1 minimum. Lighten or darken one of them until it clears.`
+      });
+    }
+    return violations;
+  }
+  static parseThemeTokens(css) {
+    const result = {};
+    CssBlockParser.walk(CssBlockParser.parse(css), "", (node, condition) => {
+      if (node.kind !== "block")
+        return null;
+      if (node.atRule === "@layer")
+        return condition;
+      if (node.atRule)
+        return CONDITIONAL_AT_RULES.has(node.atRule) ? node.prelude.replace(/\s+/g, " ") : null;
+      const scopes = node.prelude.split(",").map((selector) => ThemeValidator.#normalizeScope(selector)).filter((scope) => THEME_SCOPES.has(scope));
+      if (scopes.length === 0)
+        return null;
+      const tokens = ThemeValidator.#customProperties(node);
+      for (const scope of scopes) {
+        const key = condition ? `${condition} ${scope}` : scope;
+        result[key] = Object.assign(result[key] ?? {}, tokens);
+      }
+      return null;
+    });
+    return result;
+  }
+  static #customProperties(block) {
+    const tokens = {};
+    for (const node of block.nodes) {
+      if (node.kind === "declaration" && node.property.startsWith("--"))
+        tokens[node.property.slice(2)] = node.value;
+    }
+    return tokens;
+  }
+  static #overlayPairs(underlying, tokens) {
+    const effective = {};
+    for (const name of PAIRS.flatMap(({ base, fg }) => [base, fg])) {
+      const value = tokens[name] ?? underlying[name];
+      if (value)
+        effective[name] = value;
+    }
+    return effective;
+  }
+  static #normalizeScope(selector) {
+    return selector.replace(/\[data-theme=['"]?([\w-]+)['"]?\]/g, '[data-theme="$1"]').trim();
+  }
+  static parseHex(value) {
+    const v = value.trim();
+    if (!v.startsWith("#"))
+      return null;
+    const hex = v.slice(1);
+    let full;
+    if (hex.length === 3 || hex.length === 4)
+      full = hex.slice(0, 3).split("").map((c) => c + c).join("");
+    else if (hex.length === 6 || hex.length === 8)
+      full = hex.slice(0, 6);
+    else
+      return null;
+    if (!/^[0-9a-fA-F]{6}$/.test(full))
+      return null;
+    const n = Number.parseInt(full, 16);
+    return [n >> 16 & 255, n >> 8 & 255, n & 255];
+  }
+  static #relativeLuminance([r, g, b]) {
+    const channel = (c) => {
+      const s = c / 255;
+      return s <= 0.03928 ? s / 12.92 : ((s + 0.055) / 1.055) ** 2.4;
+    };
+    return 0.2126 * channel(r) + 0.7152 * channel(g) + 0.0722 * channel(b);
+  }
+  static contrastRatio(a, b) {
+    const la = ThemeValidator.#relativeLuminance(a);
+    const lb = ThemeValidator.#relativeLuminance(b);
+    const hi = Math.max(la, lb);
+    const lo = Math.min(la, lb);
+    return (hi + 0.05) / (lo + 0.05);
+  }
+}
+
+export { countBlocking, formatStyleContract, CssBlockParser, ThemeValidator };

package/index-665zp9rs.js

@@ -0,0 +1,271 @@
+// @bun
+import {
+  resolveSsrPageEntriesForApp
+} from "./index-va06nr10.js";
+import {
+  bundleDefine,
+  CsrEntryFiles,
+  PagesEntrySourceGenerator,
+  PagesBundleBuilder
+} from "./index-192ha4xh.js";
+
+// pkgs/@akanjs/devkit/frontendBuild/csrArtifactBuilder.ts
+import { mkdir, rm, unlink } from "fs/promises";
+import path2 from "path";
+
+// pkgs/@akanjs/devkit/transforms/browserDirnamePlugin.ts
+import path from "path";
+var vendorScript = /[\\/]node_modules[\\/].+\.[cm]?js$/;
+var createBrowserDirnamePlugin = () => ({
+  name: "akan-browser-dirname",
+  setup(build) {
+    build.onLoad({ filter: vendorScript }, async (args) => {
+      const source = await Bun.file(args.path).text();
+      if (!source.includes("__dirname") && !source.includes("__filename"))
+        return;
+      const posixPath = args.path.replaceAll("\\", "/");
+      const filename = posixPath.slice(posixPath.indexOf("/node_modules/"));
+      const define = { __dirname: JSON.stringify(path.posix.dirname(filename)), __filename: JSON.stringify(filename) };
+      return {
+        loader: "js",
+        contents: new Bun.Transpiler({ loader: "js", target: "browser", define }).transformSync(source)
+      };
+    });
+  }
+});
+
+// pkgs/@akanjs/devkit/frontendBuild/csrArtifactBuilder.ts
+class CsrArtifactBuilder {
+  #app;
+  #command;
+  #lang;
+  #cssAssets;
+  constructor(app, command = "start", lang = "en", { cssAssets = null } = {}) {
+    this.#app = app;
+    this.#command = command;
+    this.#lang = lang;
+    this.#cssAssets = cssAssets;
+  }
+  async build() {
+    const pageKeys = await this.#app.getPageKeys();
+    if (pageKeys.length === 0) {
+      this.#app.log(`[cli] no route files under ${this.#app.cwdPath}/page \u2014 skipping CSR build`);
+      return null;
+    }
+    const pageEntries = await resolveSsrPageEntriesForApp(this.#app, pageKeys);
+    const akanConfig = await this.#app.getConfig();
+    const cssAssets = await this.#loadCssAssets();
+    const basePaths = [...akanConfig.basePaths];
+    const htmlBasePaths = basePaths.length > 0 ? basePaths : [""];
+    await rm(this.#outputDir, { recursive: true, force: true });
+    await mkdir(this.#generatedDir, { recursive: true });
+    const generatedFiles = Object.fromEntries((await Promise.all(htmlBasePaths.map(async (basePath) => [
+      this.#createHtmlFile(basePath),
+      await this.#createEntryFile(basePath, CsrArtifactBuilder.pageEntriesForBasePath(pageEntries, basePath, basePaths))
+    ]))).flat());
+    const options = CsrArtifactBuilder.bundleOptions(this.#app, this.#command, akanConfig.optimizeImports);
+    const result = await Bun.build({
+      ...options,
+      entrypoints: htmlBasePaths.map((basePath) => this.#generatedPath(CsrArtifactBuilder.htmlFilename(basePath))),
+      files: generatedFiles,
+      root: this.#generatedDir,
+      outdir: this.#outputDir
+    });
+    if (!result.success) {
+      const logs = result.logs.map((log) => log.message).join(`
+`);
+      throw new Error(`[csr-build] failed${logs ? `
+${logs}` : ""}`);
+    }
+    await this.#inlineCsrArtifacts(cssAssets);
+    if (this.#command === "build")
+      await CsrArtifactBuilder.writePublicEnv(this.#app, options.define);
+    this.#app.verbose(`[csr-build] output -> ${this.#outputDir}`);
+    return { outputDir: this.#outputDir };
+  }
+  static bundleOptions(app, command, optimizeImports = []) {
+    return {
+      target: "browser",
+      splitting: false,
+      minify: true,
+      define: bundleDefine(app, command, "csr"),
+      optimizeImports,
+      plugins: [PagesBundleBuilder.createCssStubPlugin(), createBrowserDirnamePlugin()]
+    };
+  }
+  static publicEnvPath(app) {
+    return path2.join(app.dist.cwdPath, ".akan", "artifact", "csr-public-env.json");
+  }
+  static async writePublicEnv(app, define) {
+    const prefix = "process.env.";
+    const publicEnv = Object.fromEntries(Object.entries(define).filter(([key]) => key.startsWith(`${prefix}AKAN_PUBLIC_`)).map(([key, value]) => [key.slice(prefix.length), JSON.parse(value)]));
+    await Bun.write(CsrArtifactBuilder.publicEnvPath(app), `${JSON.stringify(publicEnv, null, 2)}
+`);
+  }
+  static pageEntriesForBasePath(pageEntries, basePath, basePaths) {
+    return CsrEntryFiles.pageEntriesForBasePath(pageEntries, basePath, basePaths);
+  }
+  static htmlFilename(basePath) {
+    return `${basePath || "index"}.html`;
+  }
+  static entryFilename(basePath) {
+    return CsrEntryFiles.entryFilename(basePath);
+  }
+  static basePathOfHtml(htmlPath) {
+    const name = path2.basename(htmlPath, ".html");
+    return name === "index" ? "" : name;
+  }
+  get #outputDir() {
+    return path2.join(this.#command === "build" ? this.#app.dist.cwdPath : this.#app.cwdPath, this.#command === "build" ? "csr" : ".akan/artifact/csr");
+  }
+  get #generatedDir() {
+    return path2.join(this.#app.cwdPath, ".akan/generated/csr");
+  }
+  get #artifactDir() {
+    return path2.join(this.#command === "build" ? this.#app.dist.cwdPath : this.#app.cwdPath, ".akan/artifact");
+  }
+  #generatedPath(filename) {
+    return path2.join(this.#generatedDir, filename);
+  }
+  async#createEntryFile(basePath, pageEntries) {
+    return [
+      this.#generatedPath(CsrArtifactBuilder.entryFilename(basePath)),
+      `import { bootCsr } from "akanjs/webkit";
+${await PagesEntrySourceGenerator.generateStatic(pageEntries)}
+void bootCsr(pages);
+`
+    ];
+  }
+  #createHtmlFile(basePath) {
+    return [
+      this.#generatedPath(CsrArtifactBuilder.htmlFilename(basePath)),
+      `<!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="./${CsrArtifactBuilder.entryFilename(basePath)}"></script>
+  </body>
+</html>
+  `
+    ];
+  }
+  async#loadCssAssets() {
+    if (this.#cssAssets)
+      return this.#cssAssets;
+    const artifactFile = Bun.file(path2.join(this.#artifactDir, "base-artifact.json"));
+    if (!await artifactFile.exists())
+      return {};
+    const artifact = await artifactFile.json();
+    return artifact.cssAssets ?? {};
+  }
+  async#inlineCsrArtifacts(cssAssets) {
+    const jsFiles = new Set;
+    for (const htmlPath of await this.#listOutputFiles((filePath) => filePath.endsWith(".html"))) {
+      const htmlFile = Bun.file(htmlPath);
+      if (!await htmlFile.exists())
+        continue;
+      const basePath = CsrArtifactBuilder.basePathOfHtml(htmlPath);
+      const cssAsset = cssAssets[basePath];
+      if (!cssAsset) {
+        this.#app.logger.warn(`[csr-build] base-artifact.json has no compiled stylesheet for ${basePath || "root"}; ${path2.basename(htmlPath)} ships without CSS`);
+      }
+      const inlined = await this.#inlineHtmlAssets(await htmlFile.text(), htmlPath, cssAsset);
+      for (const filePath of inlined.jsFiles)
+        jsFiles.add(filePath);
+      await Bun.write(htmlPath, inlined.html);
+    }
+    for (const filePath of jsFiles)
+      await unlink(filePath).catch(() => {
+        return;
+      });
+    const remainingAssets = await this.#listOutputFiles((filePath) => filePath.endsWith(".js") || filePath.endsWith(".css"));
+    if (remainingAssets.length > 0) {
+      throw new Error(`[csr-build] expected single-file HTML, but CSR assets remain:
+${remainingAssets.join(`
+`)}`);
+    }
+  }
+  async#inlineHtmlAssets(html, htmlPath, cssAsset) {
+    let next = html;
+    if (cssAsset) {
+      const css = await Bun.file(path2.join(this.#artifactDir, cssAsset.cssRelPath)).text();
+      next = CsrArtifactBuilder.injectBeforeHeadEnd(next, CsrArtifactBuilder.createInlineStyle(css));
+    }
+    const jsFiles = [];
+    next = await CsrArtifactBuilder.replaceModuleScriptSrc(next, async (src) => {
+      const jsPath = CsrArtifactBuilder.resolveHtmlAssetPath(htmlPath, src);
+      jsFiles.push(jsPath);
+      return await Bun.file(jsPath).text();
+    });
+    return { html: next, jsFiles };
+  }
+  async#listOutputFiles(predicate) {
+    const glob = new Bun.Glob("**/*");
+    const files = [];
+    for await (const filePath of glob.scan({ cwd: this.#outputDir, absolute: true })) {
+      if (predicate(filePath))
+        files.push(filePath);
+    }
+    return files.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  }
+  static injectBeforeHeadEnd(html, snippet) {
+    const scannable = CsrArtifactBuilder.blankEmbeddedContent(html);
+    const headEnd = scannable.search(/<\/head\s*>/i);
+    if (headEnd !== -1)
+      return `${html.slice(0, headEnd)}${snippet}
+${html.slice(headEnd)}`;
+    const bodyStart = scannable.search(/<body(?:\s|>)/i);
+    if (bodyStart !== -1)
+      return `${html.slice(0, bodyStart)}${snippet}
+${html.slice(bodyStart)}`;
+    return `${html}
+${snippet}`;
+  }
+  static blankEmbeddedContent(html) {
+    return html.replace(/<script\b[^>]*>[\s\S]*?(?:<\/script(?:[\s/][^<>]*)?>|$)|<style\b[^>]*>[\s\S]*?(?:<\/style(?:[\s/][^<>]*)?>|$)|<!--[\s\S]*?(?:--!?>|$)/gi, (match) => " ".repeat(match.length));
+  }
+  static createInlineStyle(css) {
+    return `<style data-akan-css="active">
+${css.replace(/<\/style/gi, "<\\/style")}
+</style>`;
+  }
+  static async replaceModuleScriptSrc(html, loadScript) {
+    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">
+${CsrArtifactBuilder.escapeInlineScript(await loadScript(src))}
+</script>`;
+      lastIndex = match.index + full.length;
+    }
+    if (!matched)
+      return html;
+    return result + html.slice(lastIndex);
+  }
+  static escapeInlineScript(source) {
+    return source.replace(/<\/script/gi, "<\\/script");
+  }
+  static resolveHtmlAssetPath(htmlPath, src) {
+    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 path2.resolve(path2.dirname(htmlPath), normalized);
+  }
+}
+
+export { CsrArtifactBuilder };

package/{index-2etcv0sc.js → index-86jt2a0e.js}

@@ -2,7 +2,7 @@
 import {
   runner,
   script
-} from "./index-6jjtnhkw.js";
+} from "./index-jw1zm273.js";
 
 // pkgs/@akanjs/cli/page/page.runner.ts
 class PageRunner extends runner("page") {