akanjs 3.0.0-beta.20 → 3.0.0-beta.21

package/vendor/@akanjs/native/packages/cli/src/commands/build.ts

@@ -0,0 +1,101 @@
+
+
+import { relative } from "node:path";
+import { checkFlags, type ParsedArgs, parseArgs, stringFlag } from "../lib/args.ts";
+import { bold, CliError, dim, log } from "../lib/log.ts";
+import { type BuildContext, type BuildProfile, prepare } from "../lib/prepare.ts";
+import { findAppDir, loadProject } from "../lib/project.ts";
+import { PLATFORM_TARGETS, TARGETS, type TargetPlatform } from "../platforms/index.ts";
+import { physicalIosDevice } from "../platforms/ios.ts";
+
+export const BOOLEAN_FLAGS = ["skip-web-build", "open", "release", "debug", "headless", "aab"];
+
+/** Flags of every build: the app, the env mode (.env.<mode>), the profile, the web build. */
+export const BUILD_FLAGS = ["app", "mode", "release", "debug", "skip-web-build", "aab", "device", "build"];
+/** Flags of launching a build (web server, simulators, emulators). */
+export const LAUNCH_FLAGS = ["port", "host", "open", "headless", "device", "avd"];
+
+export const BUILD_USAGE = `akan-native build <${TARGETS.join("|")}> [--app <dir>] [--mode <mode>] [--debug] [--skip-web-build] [--aab] [--device] [--build <n>]`;
+export const RUN_USAGE = `akan-native run <${TARGETS.join("|")}> [--app <dir>] [--mode <mode>] [--release] [--skip-web-build] [--port <n>] [--open] [--headless] [--device <name>] [--avd <name>] [--start <path>]`;
+
+export interface BuildDefaults {
+  /** .env.<mode>, unless --mode */
+  mode: string;
+  /** Unless --release or --debug (commands that allow them). */
+  profile: BuildProfile;
+}
+
+export async function buildFromArgs(
+  args: ParsedArgs,
+  defaults: BuildDefaults,
+  platformOverride?: TargetPlatform,
+  extra: { devServer?: string; startPath?: string } = {},
+): Promise<{ ctx: BuildContext; artifact: string; platform: TargetPlatform }> {
+  const platform = platformOverride ?? (args.positional[0] as TargetPlatform | undefined);
+  if (!platform || !TARGETS.includes(platform)) throw new CliError(`expected a platform: ${TARGETS.join(", ")}`, 2);
+  if (args.flags.release === true && args.flags.debug === true)
+    throw new CliError("--release and --debug exclude each other", 2);
+  const profile: BuildProfile =
+    args.flags.release === true ? "release" : args.flags.debug === true ? "debug" : defaults.profile;
+
+  const started = performance.now();
+  const appDir = findAppDir(stringFlag(args, "app") ?? process.cwd());
+  const project = await loadProject(appDir);
+  
+  const buildNumber = stringFlag(args, "build") ?? process.env.AKAN_NATIVE_BUILD;
+  if (buildNumber !== undefined) {
+    if (!/^[1-9][0-9]*$/.test(buildNumber))
+      throw new CliError(
+        `--build / AKAN_NATIVE_BUILD must be a positive integer (got ${JSON.stringify(buildNumber)})`,
+        2,
+      );
+    project.config.app.build = Number(buildNumber);
+  }
+  log.step(
+    `${bold(project.config.app.name)} ${dim(`(${project.config.app.id} ${project.config.app.version})`)} → ${platform}`,
+  );
+  if (project.plugins.length) log.info(dim(`plugins: ${project.plugins.map((p) => p.manifest.id).join(", ")}`));
+
+  if (args.flags.aab === true && platform !== "android") throw new CliError("--aab is for android", 2);
+  
+  const device = args.flags.device;
+  const iphone = platform === "ios" && typeof device === "string" ? await physicalIosDevice(device) : null;
+  const iosDevice = platform === "ios" && (device === true || iphone !== null);
+  const ctx = await prepare(project, platform, {
+    mode: stringFlag(args, "mode") ?? defaults.mode,
+    profile,
+    skipWebBuild: args.flags["skip-web-build"] === true,
+    devServer: extra.devServer,
+    startPath: extra.startPath,
+    
+    ...(args.flags.aab === true ? { android: { bundle: true } } : {}),
+
+    ...(iosDevice
+      ? { ios: { device: true, ...(iphone ? { target: { udid: iphone.udid, name: iphone.name } } : {}) } }
+      : {}),
+  });
+  const artifact = await PLATFORM_TARGETS[platform].build(ctx);
+  const others = ctx.artifacts.map((a) => ` + ${relative(process.cwd(), a.path) || a.path}`).join("");
+  log.ok(
+    `built ${relative(process.cwd(), artifact) || artifact}${others} ${dim(`in ${Math.round(performance.now() - started)} ms`)}`,
+  );
+  return { ctx, artifact, platform };
+}
+
+/** `akan-native build`: a release build unless --debug. */
+export async function build(argv: string[]): Promise<number> {
+  const args = parseArgs(argv, BOOLEAN_FLAGS);
+  checkFlags(args, BUILD_FLAGS, BUILD_USAGE);
+  await buildFromArgs(args, { mode: "production", profile: "release" });
+  return 0;
+}
+
+/** `akan-native run`: a debug build unless --release. */
+export async function run(argv: string[]): Promise<number> {
+  const args = parseArgs(argv, BOOLEAN_FLAGS);
+  checkFlags(args, [...BUILD_FLAGS, ...LAUNCH_FLAGS, "start"], RUN_USAGE);
+  const { ctx, artifact, platform } = await buildFromArgs(args, { mode: "development", profile: "debug" }, undefined, {
+    startPath: stringFlag(args, "start"),
+  });
+  return PLATFORM_TARGETS[platform].run(ctx, artifact, args);
+}

package/vendor/@akanjs/native/packages/cli/src/commands/compat.ts

@@ -0,0 +1,53 @@
+
+
+import { resolve } from "node:path";
+import { resolveAcl } from "../lib/acl.ts";
+import { parseArgs, stringFlag } from "../lib/args.ts";
+import { runtimeVersion } from "../lib/boot.ts";
+import { compatProblems, nativeApi, nativeApiHash, readBundleInfo } from "../lib/compat.ts";
+import { bold, CliError, dim, log } from "../lib/log.ts";
+import { type NativePlatform, pluginDecls } from "../lib/native-plugins.ts";
+import { findAppDir, loadProject } from "../lib/project.ts";
+
+const COMPAT_PLATFORMS: readonly NativePlatform[] = ["macos", "windows", "linux", "ios", "android"];
+export const COMPAT_USAGE = `akan-native compat <${COMPAT_PLATFORMS.join("|")}> [--against <bundle.json>] [--app <dir>]`;
+
+export async function compat(argv: string[]): Promise<number> {
+  const args = parseArgs(argv);
+  const platform = args.positional[0] as NativePlatform | undefined;
+  if (!platform || !COMPAT_PLATFORMS.includes(platform)) throw new CliError(`usage: ${COMPAT_USAGE}`, 2);
+  const project = await loadProject(findAppDir(stringFlag(args, "app") ?? process.cwd()));
+  const decls = pluginDecls(project.plugins, platform);
+  const current = nativeApi(
+    project,
+    platform,
+    decls,
+    resolveAcl(project.config.capabilities, project.plugins, platform),
+    runtimeVersion(),
+  );
+  const hash = nativeApiHash(current);
+  const against = stringFlag(args, "against");
+  if (!against) {
+    log.info(
+      `${platform} native API ${bold(hash)} ${dim(`(runtime ${current.runtime}, ${Object.keys(current.plugins).length} plugins)`)}`,
+    );
+    log.info(
+      dim(
+        "Builds write it to .akan/native/build/<platform>/bundle.json; keep the one of each store release for --against.",
+      ),
+    );
+    return 0;
+  }
+  const shipped = readBundleInfo(resolve(against));
+  const where = `${shipped.app.id} ${shipped.app.version} (${shipped.app.build}) ${shipped.nativeApi.hash}`;
+  if (shipped.app.id !== project.config.app.id)
+    throw new CliError(`${against} is for ${shipped.app.id}, this app is ${project.config.app.id}`);
+  const problems = compatProblems(shipped.nativeApi.inputs, current);
+  if (!problems.length) {
+    log.ok(`compatible with ${where}: a web-only update can run in that binary`);
+    return 0;
+  }
+  log.error(`needs a new app binary: ${where} provides a different native API (now ${hash})`);
+  for (const p of problems) log.info(`- ${p}`);
+  return 1;
+}

package/vendor/@akanjs/native/packages/cli/src/commands/dev.ts

@@ -0,0 +1,249 @@
+
+
+import { cpSync, mkdirSync, rmSync, watch, writeFileSync } from "node:fs";
+import { join, relative, resolve, sep } from "node:path";
+import { checkFlags, type ParsedArgs, parseArgs, stringFlag } from "../lib/args.ts";
+import { openHeadless } from "../lib/chrome.ts";
+import { type HmrContext, lanAddress, resolveDevEntry, startHmrServer } from "../lib/hmr.ts";
+import { envFromProcess, type Launched, onStopSignal, printLine } from "../lib/launch.ts";
+import { bold, CliError, dim, log } from "../lib/log.ts";
+import { prepare } from "../lib/prepare.ts";
+import { findAppDir, loadProject } from "../lib/project.ts";
+import { LiveReload } from "../lib/serve.ts";
+import { launchAndroid } from "../platforms/android.ts";
+import { type DesktopOs, resourcesOf } from "../platforms/desktop.ts";
+import { PLATFORM_TARGETS, TARGETS, type TargetPlatform } from "../platforms/index.ts";
+import { buildWeb } from "../platforms/web.ts";
+import { launchWeb, webInitScript } from "../platforms/web-run.ts";
+import { BOOLEAN_FLAGS, buildFromArgs, LAUNCH_FLAGS } from "./build.ts";
+
+export const DEV_USAGE =
+  `akan-native dev <${TARGETS.join("|")}> [--app <dir>] [--mode <mode>] [--port <n>] [--headless] [--hmr] [--device <name>] [--avd <name>]` +
+  ` [--upstream <url>] [--hmr-path <path>] [--start <path>] [--lan]`;
+
+/** Always a debug build (live reload, the dev server). */
+const DEBUG = { mode: "development", profile: "debug" } as const;
+
+const IGNORED = /(^|\/)(node_modules|\.akan|\.git|\.DS_Store)(\/|$)|\.log$|^akan-native-env\.d\.ts$/;
+
+/** Files whose change needs a new native build (and init.js) with --hmr; Bun handles the rest. */
+const CONFIG_FILE = /^(akan-native\.config\.(ts|js|mjs)|\.env(\..+)?)$/;
+
+export async function dev(argv: string[]): Promise<number> {
+  const args = parseArgs(argv, [...BOOLEAN_FLAGS, "hmr", "lan"]);
+  checkFlags(
+    args,
+    ["app", "mode", "skip-web-build", "hmr", "upstream", "hmr-path", "start", "lan", ...LAUNCH_FLAGS],
+    DEV_USAGE,
+  );
+  const platform = args.positional[0] as TargetPlatform | undefined;
+  if (!platform || !TARGETS.includes(platform)) throw new CliError(`expected a platform: ${TARGETS.join(", ")}`, 2);
+  const headless = args.flags.headless === true;
+  const env = envFromProcess();
+  
+  if (args.flags.hmr === true || stringFlag(args, "upstream")) return devHmr(platform, args, env, headless);
+
+  const desktop =
+    platform === "macos" || platform === "windows" || platform === "linux" ? (platform as DesktopOs) : null;
+  let { ctx, artifact } = await buildFromArgs(args, DEBUG, platform, { startPath: stringFlag(args, "start") });
+  const reload = new LiveReload();
+  let app: Launched;
+  if (platform === "web") {
+    app = await launchWeb(ctx, artifact, {
+      env,
+      headless: false,
+      port: Number(stringFlag(args, "port") ?? 4173),
+      liveReload: reload,
+      onReady: (url) => log.ok(`dev server ${bold(url)} (live reload)`),
+    });
+  } else {
+    app = await PLATFORM_TARGETS[platform].launch(ctx, artifact, {
+      env: { ...env, AKAN_NATIVE_DEV_WATCH: "1" },
+      headless,
+    });
+  }
+
+  const webDir = ctx.webDir;
+  const appDir = ctx.project.appDir;
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  let running: Promise<void> = Promise.resolve();
+  const changed = new Set<string>();
+
+  const rebuild = async () => {
+    const files = [...changed];
+    changed.clear();
+    log.step(`changed: ${files.slice(0, 3).join(", ")}${files.length > 3 ? ` +${files.length - 3}` : ""}`);
+    const started = performance.now();
+    try {
+      if (platform === "web") {
+        ctx = await prepare(ctx.project, "web", { mode: ctx.mode, profile: "debug", skipWebBuild: false });
+        await buildWeb(ctx);
+        reload.reload();
+      } else if (desktop) {
+        
+        const next = await prepare(ctx.project, platform, { mode: ctx.mode, profile: "debug", skipWebBuild: false });
+        const target = join(resourcesOf(desktop, artifact), "app");
+        rmSync(target, { recursive: true, force: true });
+        mkdirSync(target, { recursive: true });
+        cpSync(next.webDir, target, { recursive: true });
+        writeFileSync(join(target, "index.html"), next.html);
+        ctx = next;
+      } else {
+        app.stop();
+        await app.exited.catch(() => 0);
+        const { "skip-web-build": _skip, ...flags } = args.flags;
+        ({ ctx, artifact } = await buildFromArgs({ ...args, flags }, DEBUG, platform, {
+          startPath: stringFlag(args, "start"),
+        }));
+        app = await PLATFORM_TARGETS[platform].launch(ctx, artifact, {
+          env: { ...env, AKAN_NATIVE_DEV_WATCH: "1" },
+          headless,
+        });
+      }
+      log.ok(`updated in ${Math.round(performance.now() - started)} ms`);
+    } catch (error) {
+      log.error(error instanceof Error ? error.message : String(error));
+    }
+  };
+
+  const watcher = watch(appDir, { recursive: true }, (_event, file) => {
+    if (!file) return;
+    const path = resolve(appDir, file);
+    const rel = relative(appDir, path).split(sep).join("/");
+    
+    if (IGNORED.test(rel) || path === webDir || path.startsWith(webDir + sep)) return;
+    changed.add(rel);
+    clearTimeout(timer);
+    timer = setTimeout(() => {
+      running = running.then(rebuild);
+    }, 200);
+  });
+  log.info(dim(`watching ${appDir} (Ctrl+C to stop)`));
+  if (desktop) log.info(dim(`app: ${ctx.project.config.app.fileName}`));
+
+  await new Promise<void>((done) => {
+    const off = onStopSignal(() => {
+      off();
+      done();
+    });
+  });
+  watcher.close();
+  app.stop();
+  return 0;
+}
+
+async function devHmr(
+  platform: TargetPlatform,
+  args: ParsedArgs,
+  env: Record<string, string>,
+  headless: boolean,
+): Promise<number> {
+  const appDir = findAppDir(stringFlag(args, "app") ?? process.cwd());
+  const context: HmrContext = { project: await loadProject(appDir) };
+  const upstream = stringFlag(args, "upstream");
+  const entry = upstream ? undefined : resolveDevEntry(context.project);
+  const native = platform !== "web";
+  
+  const lan = args.flags.lan === true && platform === "ios" ? lanAddress() : undefined;
+  if (args.flags.lan === true && platform === "ios" && !lan)
+    throw new CliError("--lan: this Mac has no private IPv4 address on a network");
+  log.step(upstream ? `dev gateway for ${upstream}` : `hmr: Bun dev server for ${relative(appDir, entry!) || entry}`);
+  const server = await startHmrServer({
+    platform,
+    entry,
+    upstream,
+    hmrPath: stringFlag(args, "hmr-path"),
+    
+    port: Number(stringFlag(args, "port") ?? (native ? 0 : 4173)),
+    hostname: lan ? "0.0.0.0" : native ? "127.0.0.1" : "localhost",
+    publicHost: lan,
+    context,
+    onLine: (line) => log.info(dim(`[bun] ${line}`)),
+    onWarning: (text) => log.warn(text),
+  });
+  const devServer = native ? server.url : undefined;
+  const startPath = stringFlag(args, "start");
+
+  let flags = args.flags;
+  const launch = async (): Promise<Launched> => {
+    const { ctx, artifact } = await buildFromArgs({ ...args, flags }, DEBUG, platform, { devServer, startPath });
+    context.project = ctx.project;
+    if (!native) {
+      context.initScript = () => webInitScript(ctx, env);
+      return launchedNothing(headless ? await openHeadless(server.url, printLine) : undefined);
+    }
+    const opts = { env, headless };
+    const device = stringFlag(args, "device");
+    return platform === "android"
+      ? launchAndroid(ctx, artifact, { ...opts, reverse: [server.port], device, avd: stringFlag(args, "avd") })
+      : PLATFORM_TARGETS[platform].launch(ctx, artifact, { ...opts, ...(device ? { device } : {}) } as never);
+  };
+  let app: Launched;
+  try {
+    app = await launch();
+  } catch (error) {
+    server.stop();
+    throw error;
+  }
+  log.ok(
+    `${native ? "pages from" : "dev server"} ${bold(server.url)}${upstream ? ` → ${upstream}` : " (HMR: React Fast Refresh keeps component state)"}`,
+  );
+  
+  flags = { ...flags, "skip-web-build": true };
+
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  let running: Promise<void> = Promise.resolve();
+  const rebuild = async (file: string) => {
+    log.step(`changed: ${file}, rebuilding`);
+    try {
+      app.stop();
+      await app.exited.catch(() => 0);
+      app = await launch();
+      log.ok(native ? "relaunched" : "updated (reload the page for the new env)");
+    } catch (error) {
+      log.error(error instanceof Error ? error.message : String(error));
+    }
+  };
+  const watcher = watch(appDir, (_event, file) => {
+    if (!file || !CONFIG_FILE.test(file)) return;
+    clearTimeout(timer);
+    timer = setTimeout(() => {
+      running = running.then(() => rebuild(file));
+    }, 200);
+  });
+  log.info(dim(`Bun watches the sources; akan-native.config.* and .env* changes rebuild the app (Ctrl+C to stop)`));
+
+  let failure: unknown;
+  await new Promise<void>((done) => {
+    const off = onStopSignal(() => {
+      off();
+      done();
+    });
+    server.exited.catch((error) => {
+      failure = error;
+      off();
+      done();
+    });
+  });
+  watcher.close();
+  clearTimeout(timer);
+  app.stop();
+  
+  await Promise.race([app.exited.catch(() => 0), Bun.sleep(3000)]);
+  server.stop();
+  if (failure) throw failure;
+  return 0;
+}
+
+/** web --hmr: the browser is the user's (or headless Chrome with --headless). */
+function launchedNothing(browser?: { stop(): void; exited: Promise<number> }): Launched {
+  let resolveExit!: (code: number) => void;
+  const exited = new Promise<number>((resolve) => (resolveExit = resolve));
+  return {
+    exited,
+    stop() {
+      browser?.stop();
+      resolveExit(0);
+    },
+  };
+}