akanjs 2.0.7 → 2.1.0-rc.0

package/devkit/artifact/routeSeedIndex.ts

@@ -1,128 +0,0 @@
-import path from "node:path";
-import { assertUniqueRoutePatterns, compareRouteSpecificity, parseRouteModuleKey } from "akanjs/common";
-import type { PageEntry } from "./implicitRootLayout";
-
-/**
- * Build-time utilities for the route seed index. `computeRouteSeedIndex`
- * takes resolved `PageEntry` rows (`key` plus absolute module path — files
- * under `app/` or the generated implicit root layout) and produces — for every
- * route — the list of source files that seed the `"use client"` graph walk.
- *
- * The result is serialized to `route-seed-index.json` by
- * `saveRouteSeedIndex` so the runtime server can call
- * `loadRouteSeedIndex` to restore it without re-importing `pages.ts`
- * (which no longer exists) or reparsing loader sources.
- */
-
-export interface RouteSeedEntry {
-  routeId: string;
-  pattern: string;
-  seeds: string[];
-}
-
-export interface RouteSeedIndex {
-  entries: RouteSeedEntry[];
-  globalLayoutFiles: string[];
-}
-
-export type SerializedRouteSeedEntry = Pick<RouteSeedEntry, "routeId"> &
-  Partial<Pick<RouteSeedEntry, "pattern" | "seeds">>;
-
-export interface SerializedRouteSeedIndex {
-  entries: SerializedRouteSeedEntry[];
-  globalLayoutFiles?: string[];
-}
-
-/**
- * Compute the route seed index from `PageEntry`s (disk paths or generated
- * implicit root layout absolute paths).
- */
-export function computeRouteSeedIndex(pageEntries: PageEntry[]): RouteSeedIndex {
-  const layoutsByPrefix = new Map<string, string[]>();
-  const pagesBySegments: Array<{
-    key: string;
-    pattern: string;
-    segments: string[];
-    files: string[];
-    includeOwnLayout: boolean;
-  }> = [];
-
-  for (const { key, moduleAbsPath, seedAbsPaths } of pageEntries) {
-    const parsed = parseRouteModuleKey(key);
-    const files = [path.resolve(moduleAbsPath), ...(seedAbsPaths ?? []).map((seed) => path.resolve(seed))];
-    if (parsed.kind === "layout") {
-      const prefix = parsed.routeSegments.join("/");
-      const prev = layoutsByPrefix.get(prefix) ?? [];
-      layoutsByPrefix.set(prefix, [...prev, ...files]);
-    } else if (parsed.kind === "page") {
-      pagesBySegments.push({
-        key,
-        pattern: parsed.pattern,
-        segments: parsed.routeSegments,
-        files,
-        includeOwnLayout: parsed.leaf === "_index",
-      });
-    }
-  }
-  assertUniqueRoutePatterns(pagesBySegments);
-
-  const rootLayouts = layoutsByPrefix.get("") ?? [];
-  const globalLayoutFiles = rootLayouts;
-
-  const seedEntries: RouteSeedEntry[] = [];
-  for (const { pattern, segments, files, includeOwnLayout } of pagesBySegments) {
-    const layouts: string[] = [];
-    const maxPrefixLength = includeOwnLayout ? segments.length : Math.max(segments.length - 1, 0);
-    for (let i = 0; i <= maxPrefixLength; i++) {
-      const prefix = segments.slice(0, i).join("/");
-      const layoutFiles = layoutsByPrefix.get(prefix);
-      if (layoutFiles) layouts.push(...layoutFiles);
-    }
-    const seeds = Array.from(new Set([...layouts, ...files]));
-    const routeId = pattern || "/";
-    seedEntries.push({ routeId, pattern: routeId, seeds });
-  }
-
-  seedEntries.sort((a, b) => compareRouteSpecificity(a.pattern, b.pattern));
-  return { entries: seedEntries, globalLayoutFiles };
-}
-
-export const ROUTE_SEED_INDEX_JSON = "route-seed-index.json";
-
-export function serializeRouteSeedIndexForArtifact(
-  index: RouteSeedIndex,
-  artifactDir: string,
-  options: { production?: boolean } = {},
-): SerializedRouteSeedIndex {
-  const normalizedArtifactDir = path.resolve(artifactDir);
-  if (options.production) {
-    return {
-      entries: index.entries.map((entry) => ({ routeId: entry.routeId })),
-    };
-  }
-  return {
-    entries: index.entries.map((entry) => ({
-      ...entry,
-      seeds: entry.seeds.map((seed) => serializeArtifactPath(seed, normalizedArtifactDir)),
-    })),
-    globalLayoutFiles: index.globalLayoutFiles.map((file) => serializeArtifactPath(file, normalizedArtifactDir)),
-  };
-}
-
-export async function saveRouteSeedIndex(
-  artifactDir: string,
-  index: RouteSeedIndex,
-  options: { production?: boolean } = {},
-): Promise<string> {
-  const absPath = path.join(path.resolve(artifactDir), ROUTE_SEED_INDEX_JSON);
-  await Bun.write(
-    absPath,
-    `${JSON.stringify(serializeRouteSeedIndexForArtifact(index, artifactDir, options), null, 2)}\n`,
-  );
-  return absPath;
-}
-
-function serializeArtifactPath(artifactPath: string, artifactDir: string): string {
-  if (!path.isAbsolute(artifactPath)) return artifactPath;
-  return path.relative(artifactDir, artifactPath).split(path.sep).join("/");
-}

package/devkit/auth.ts

@@ -1,41 +0,0 @@
-import { mkdir } from "node:fs/promises";
-
-import {
-  type AkanGlobalConfig,
-  akanCloudHost,
-  akanCloudUrl,
-  basePath,
-  configPath,
-  defaultAkanGlobalConfig,
-  defaultHostConfig,
-  type HostConfig,
-} from "./constants";
-import { FileSys } from "./fileSys";
-
-export const getAkanGlobalConfig = async () => {
-  const exists = await FileSys.fileExists(configPath);
-  const akanConfig = exists ? await FileSys.readJson<AkanGlobalConfig>(configPath) : defaultAkanGlobalConfig;
-  return akanConfig;
-};
-export const setAkanGlobalConfig = async (akanConfig: AkanGlobalConfig) => {
-  await mkdir(basePath, { recursive: true });
-  await Bun.write(configPath, JSON.stringify(akanConfig, null, 2));
-};
-export const getHostConfig = async (host = akanCloudHost) => {
-  const akanConfig = await getAkanGlobalConfig();
-  return akanConfig.cloudHost[host] ?? defaultHostConfig;
-};
-export const setHostConfig = async (host = akanCloudHost, config: HostConfig = {}) => {
-  const akanConfig = await getAkanGlobalConfig();
-  akanConfig.cloudHost[host] = config;
-  await setAkanGlobalConfig(akanConfig);
-};
-export const getSelf = async (token: string) => {
-  try {
-    const res = await fetch(`${akanCloudUrl}/user/getSelf`, { headers: { Authorization: `Bearer ${token}` } });
-    const user = (await res.json()) as { id: string; nickname: string };
-    return user;
-  } catch (e) {
-    return null;
-  }
-};

package/devkit/builder.ts

@@ -1,164 +0,0 @@
-import { existsSync } from "node:fs";
-import { mkdir } from "node:fs/promises";
-import path from "node:path";
-import type { Loader } from "bun";
-import type { Executor } from "./executors";
-import { FileSys } from "./fileSys";
-import type { PackageJson } from "./types";
-
-/** Relative paths under these directories are not used as Bun.build entrypoints (Bun does not expand `**` in entrypoint strings; we scan with {@link Bun.Glob}). */
-const SKIP_ENTRY_DIR_SET = new Set(["node_modules", "dist", "build", ".git", ".next"]);
-
-const assetExtensions = [".css", ".md", ".js", ".png", ".ico", ".svg", ".json", ".template"];
-const assetLoader = Object.fromEntries(assetExtensions.map((ext) => [ext, "file" as const])) satisfies Record<
-  string,
-  Loader
->;
-
-type BunBuildConfig = Parameters<typeof Bun.build>[0] & { bundle?: boolean };
-type ExportValue = string | string[] | { [condition: string]: ExportValue };
-
-interface BuildOptions {
-  bundle?: boolean;
-  additionalEntryPoints?: string[];
-}
-
-interface BuilderOptions {
-  executor: Executor;
-  distExecutor: Executor;
-  pkgJson: PackageJson;
-  rootPackageJson: PackageJson;
-}
-export class Builder {
-  #executor: Executor;
-  #distExecutor: Executor;
-  #pkgJson: PackageJson;
-
-  constructor({ executor, distExecutor, pkgJson }: BuilderOptions) {
-    this.#executor = executor;
-    this.#distExecutor = distExecutor;
-    this.#pkgJson = pkgJson;
-  }
-  #globEntrypoints(cwd: string, pattern: string): string[] {
-    const glob = new Bun.Glob(pattern);
-    return Array.from(glob.scanSync({ cwd, onlyFiles: true }))
-      .filter((relativePath) => {
-        const segments = relativePath.split(path.sep);
-        return !segments.some((segment) => SKIP_ENTRY_DIR_SET.has(segment));
-      })
-      .map((rel) => path.join(cwd, rel));
-  }
-  #globFiles(cwd: string, pattern = "**/*.*"): string[] {
-    const glob = new Bun.Glob(pattern);
-    return Array.from(glob.scanSync({ cwd, onlyFiles: true })).filter((relativePath) => {
-      const segments = relativePath.split(path.sep);
-      return !segments.some((segment) => SKIP_ENTRY_DIR_SET.has(segment));
-    });
-  }
-
-  #resolveAdditionalEntrypoints(cwd: string, additionalEntryPoints: string[]): string[] {
-    const out: string[] = [];
-    for (const p of additionalEntryPoints) {
-      if (p.includes("*")) {
-        const rel = p.startsWith(`${cwd}/`) || p.startsWith(`${cwd}${path.sep}`) ? p.slice(cwd.length + 1) : p;
-        out.push(...this.#globEntrypoints(cwd, rel));
-      } else out.push(path.isAbsolute(p) ? p : path.join(cwd, p));
-    }
-    return out;
-  }
-  #getBuildOptions({ bundle = false, additionalEntryPoints = [] }: BuildOptions = {}): BunBuildConfig {
-    const cwd = this.#executor.cwdPath;
-    const entrypoints = [
-      ...(bundle ? [path.join(cwd, "index.ts")] : this.#globEntrypoints(cwd, "**/*.{ts,tsx}")),
-      ...this.#resolveAdditionalEntrypoints(cwd, additionalEntryPoints),
-    ];
-    return {
-      root: cwd,
-      entrypoints,
-      bundle,
-      packages: "external",
-      splitting: false,
-      target: this.#pkgJson.bun?.platform,
-      format: "esm",
-      outdir: this.#distExecutor.cwdPath,
-      external: ["react", "react-dom"],
-      loader: assetLoader,
-    };
-  }
-  async #copySourceFiles() {
-    const cwd = this.#executor.cwdPath;
-    for (const relativePath of this.#globFiles(cwd)) {
-      if (relativePath === "package.json") continue;
-      const sourcePath = path.join(cwd, relativePath);
-      const targetPath = path.join(this.#distExecutor.cwdPath, relativePath);
-      await mkdir(path.dirname(targetPath), { recursive: true });
-      await Bun.write(targetPath, Bun.file(sourcePath));
-    }
-  }
-  #toPublishedPath(publishedPath: string, { useSource }: { useSource: boolean }) {
-    const hasDotSlash = publishedPath.startsWith("./");
-    const withoutFormatDir = publishedPath.replace(/^(?:\.\/)?(?:esm|cjs)\//, hasDotSlash ? "./" : "");
-    if (!useSource) return withoutFormatDir;
-    if (!hasDotSlash && withoutFormatDir === publishedPath) return publishedPath;
-    const parsed = path.posix.parse(withoutFormatDir);
-    if (![".js", ".mjs", ".cjs"].includes(parsed.ext)) return withoutFormatDir;
-    const withoutExt = path.posix.join(parsed.dir, parsed.name);
-    const sourcePath = withoutExt.startsWith("./") ? withoutExt.slice(2) : withoutExt;
-    const sourceCandidates = [`${sourcePath}.ts`, `${sourcePath}.tsx`];
-    const matchedSource = sourceCandidates.find((candidate) =>
-      existsSync(path.join(this.#executor.cwdPath, candidate)),
-    );
-    if (!matchedSource) return withoutFormatDir;
-    return hasDotSlash ? `./${matchedSource}` : matchedSource;
-  }
-  #normalizeExports(
-    exportsValue: ExportValue | undefined,
-    { useSource }: { useSource: boolean },
-  ): ExportValue | undefined {
-    if (!exportsValue) return exportsValue;
-    if (typeof exportsValue === "string") return this.#toPublishedPath(exportsValue, { useSource });
-    if (Array.isArray(exportsValue))
-      return exportsValue.map((value) => this.#normalizeExports(value, { useSource }) as string);
-    if (typeof exportsValue !== "object") return exportsValue;
-
-    return Object.fromEntries(
-      Object.entries(exportsValue)
-        .filter(([condition]) => condition !== "require")
-        .map(([condition, value]) => [condition, this.#normalizeExports(value, { useSource })])
-        .filter((entry): entry is [string, ExportValue] => entry[1] !== undefined),
-    );
-  }
-  #getPackageJson({ bundle = false }: BuildOptions = {}): PackageJson {
-    const rootEntry = bundle ? "./index.js" : "./index.ts";
-    const normalizedExports = this.#normalizeExports(this.#pkgJson.exports as ExportValue | undefined, {
-      useSource: !bundle,
-    });
-    return {
-      ...this.#pkgJson,
-      type: "module",
-      main: rootEntry,
-      bin: this.#normalizeExports(this.#pkgJson.bin as ExportValue | undefined, { useSource: !bundle }),
-      exports: {
-        ...((typeof normalizedExports === "object" && !Array.isArray(normalizedExports)
-          ? normalizedExports
-          : {}) as Record<string, ExportValue>),
-        ".": {
-          import: rootEntry,
-          types: bundle ? "./index.d.ts" : "./index.ts",
-        },
-      },
-    };
-  }
-  async build(options: BuildOptions = {}) {
-    if (await FileSys.dirExists(this.#distExecutor.cwdPath))
-      await this.#distExecutor.exec(`rm -rf ${this.#distExecutor.cwdPath}`);
-
-    if (options.bundle) {
-      const buildResult = await Bun.build({ ...this.#getBuildOptions(options) });
-      if (!buildResult.success) throw new AggregateError(buildResult.logs, "Bundle failed");
-    } else await this.#copySourceFiles();
-
-    const pkgPackageJson = this.#getPackageJson(options);
-    await this.#distExecutor.setPackageJson(pkgPackageJson);
-  }
-}

package/devkit/capacitor.base.config.ts

@@ -1,88 +0,0 @@
-import os from "node:os";
-import type { CapacitorConfig } from "@capacitor/cli";
-import type { AkanMobileTargetConfig, AppScanResult } from "akanjs/devkit";
-
-const getLocalIP = () => {
-  const interfaces = os.networkInterfaces();
-  for (const interfaceName in interfaces) {
-    const iface = interfaces[interfaceName];
-    if (!iface) continue;
-    for (const alias of iface) {
-      if (alias.family === "IPv4" && !alias.internal) return alias.address;
-    }
-  }
-  return "127.0.0.1"; 
-};
-
-const normalizeBasePath = (basePath: string | undefined) => basePath?.replace(/^\/+|\/+$/g, "");
-
-const routeBasePaths = (appInfo: AppScanResult) =>
-  new Set(
-    appInfo.routes
-      .map((route) => route.replace(/^\.\//, "").split("/")[0])
-      .filter((segment): segment is string => !!segment && !segment.startsWith("_") && !segment.startsWith("(")),
-  );
-
-const resolveTarget = (appInfo: AppScanResult, targetName = process.env.AKAN_MOBILE_TARGET) => {
-  const targets = appInfo.akanConfig.mobile.targets;
-  if (!targets || Object.keys(targets).length === 0) throw new Error("Akan mobile target metadata is missing.");
-  if (targetName) {
-    const target = targets[targetName];
-    if (!target) {
-      const basePath = normalizeBasePath(targetName);
-      const [template] = Object.values(targets);
-      if (basePath && template && routeBasePaths(appInfo).has(basePath))
-        return { ...template, name: basePath, basePath };
-      throw new Error(`Akan mobile target '${targetName}' was not found.`);
-    }
-    return target;
-  }
-  const entries = Object.entries(targets);
-  if (entries.length !== 1) throw new Error("AKAN_MOBILE_TARGET is required when multiple mobile targets exist.");
-  return entries[0]?.[1] as AkanMobileTargetConfig;
-};
-
-const localCsrUrl = (ip: string, target: AkanMobileTargetConfig) => {
-  const basePath = normalizeBasePath(target.basePath);
-  const port = process.env.AKAN_PUBLIC_CLIENT_PORT ?? process.env.PORT ?? "8282";
-  return `http://${ip}:${port}/${basePath ? `${basePath}` : ""}?csr=true`;
-};
-
-export const withBase = (
-  configImp: (config: CapacitorConfig, target: AkanMobileTargetConfig) => CapacitorConfig = (config) => config,
-  appData?: AppScanResult,
-  targetName?: string,
-) => {
-  const ip = getLocalIP();
-  const appInfo = appData;
-  if (!appInfo) throw new Error("withBase requires apps/<app>/akan.app.json metadata.");
-  const target = resolveTarget(appInfo, targetName);
-  const baseConfig: CapacitorConfig = {
-    ...target,
-    appId: target.appId,
-    appName: target.appName,
-    webDir: "dist",
-    server:
-      process.env.APP_OPERATION_MODE !== "release"
-        ? {
-            androidScheme: "http",
-            url: localCsrUrl(ip, target),
-            cleartext: true,
-            allowNavigation: [ip, "localhost"],
-          }
-        : {
-            allowNavigation: ["*"],
-          },
-    plugins: {
-      CapacitorCookies: { enabled: true },
-      ...target.plugins,
-    },
-    android: {
-      ...target.android,
-    },
-    ios: {
-      ...target.ios,
-    },
-  };
-  return configImp(baseConfig, target);
-};