akanjs 0.0.1 → 2.0.0-beta.0

package/devkit/capacitorApp.ts

@@ -0,0 +1,385 @@
+import { cp, mkdir, rm } from "node:fs/promises";
+import path from "node:path";
+import { MobileProject } from "@trapezedev/project";
+import type { AndroidProject } from "@trapezedev/project/dist/android/project";
+import type { IosProject } from "@trapezedev/project/dist/ios/project";
+import { capitalize } from "akanjs/common";
+import type { AkanMobileTargetConfig } from "./akanConfig";
+import type { AppExecutor } from "./executors";
+import { FileEditor } from "./fileEditor";
+import { resolveMobilePath, targetHtmlFilename } from "./mobile";
+
+interface RunConfig {
+  operation: "local" | "release";
+  env: "local" | "debug" | "develop" | "main";
+  regenerate?: boolean;
+}
+
+export class CapacitorApp {
+  project: MobileProject & { ios: IosProject; android: AndroidProject };
+  iosTargetName = "App";
+  readonly targetRoot: string;
+  constructor(
+    private readonly app: AppExecutor,
+    readonly target: AkanMobileTargetConfig,
+  ) {
+    this.targetRoot = path.join(this.app.cwdPath, "mobile", this.target.name);
+    this.project = new MobileProject(this.targetRoot, {
+      android: { path: "android" },
+      ios: { path: "ios/App" },
+    }) as MobileProject & { ios: IosProject; android: AndroidProject };
+  }
+  async init({ platform, regenerate = false }: { platform?: "ios" | "android"; regenerate?: boolean } = {}) {
+    await mkdir(this.targetRoot, { recursive: true });
+    await this.#writeCapacitorConfig();
+    if (regenerate) {
+      if (!platform || platform === "ios")
+        await rm(path.join(this.targetRoot, "ios"), { recursive: true, force: true });
+      if (!platform || platform === "android")
+        await rm(path.join(this.targetRoot, "android"), { recursive: true, force: true });
+    }
+    const project = this.project as MobileProject;
+    await this.project.load();
+    if ((!platform || platform === "android") && !project.android) {
+      await this.#spawn("npx", ["cap", "add", "android"]);
+      await this.project.load();
+    }
+    if ((!platform || platform === "ios") && !project.ios) {
+      await this.#spawn("npx", ["cap", "add", "ios"]);
+      await this.project.load();
+    }
+    return this;
+  }
+  async save() {
+    await this.project.commit();
+  }
+  async #prepareIos({ regenerate = false }: { regenerate?: boolean } = {}) {
+    await this.init({ platform: "ios", regenerate });
+    await this.#prepareTargetAssets();
+    await this.#prepareExternalFiles("ios");
+    await this.#applyIosMetadata();
+    await this.#applyPermissions();
+    await this.#applyLinks();
+    await this.project.commit();
+    await this.#generateAssets();
+    this.app.verbose(`syncing iOS`);
+    await this.#spawn("npx", ["cap", "sync", "ios"]);
+    this.app.verbose(`sync completed.`);
+  }
+  async buildIos(options: { regenerate?: boolean } = {}) {
+    await this.prepareWww();
+    await this.#prepareIos(options);
+    await this.#spawn("npx", ["cap", "build", "ios"], { stdio: "inherit" });
+    this.app.verbose(`build completed iOS.`);
+    return;
+  }
+  async syncIos() {
+    await this.#spawn("npx", ["cap", "sync", "ios"]);
+  }
+  async openIos() {
+    await this.#spawn("npx", ["cap", "open", "ios"]);
+  }
+  async runIos({ operation, env, regenerate = false }: RunConfig) {
+    if (operation === "release") await this.prepareWww();
+    await this.#prepareIos({ regenerate });
+    const args = ["cap", "run", "ios"];
+    if (operation !== "release") args.push("--live-reload");
+    await this.#spawn("npx", args, {
+      env: this.#commandEnv(operation, env),
+      stdio: "inherit",
+    });
+  }
+
+  async #prepareAndroid({ regenerate = false }: { regenerate?: boolean } = {}) {
+    await this.init({ platform: "android", regenerate });
+    await this.#prepareTargetAssets();
+    await this.#prepareExternalFiles("android");
+    await this.#applyAndroidMetadata();
+    await this.#applyPermissions();
+    await this.#applyLinks();
+    await this.project.commit();
+    await this.#generateAssets();
+    await this.#spawn("npx", ["cap", "sync", "android"]);
+  }
+
+  async #updateAndroidBuildTypes() {
+
+    const appGradle = await FileEditor.create(`${this.targetRoot}/android/app/build.gradle`);
+    const buildTypesBlock = `
+      debug {
+        applicationIdSuffix ".debug"
+        versionNameSuffix "-DEBUG"
+        debuggable true
+        minifyEnabled false
+      }
+    `;
+    const singinConfigBlock = `
+     signingConfigs {
+        debug {
+            storeFile file('debug.keystore')
+            storePassword 'android'
+            keyAlias 'androiddebugkey'
+            keyPassword 'android'
+        }
+        release {
+            if (project.hasProperty('MYAPP_RELEASE_STORE_FILE')) {
+                storeFile file(MYAPP_RELEASE_STORE_FILE)
+                storePassword MYAPP_RELEASE_STORE_PASSWORD
+                keyAlias MYAPP_RELEASE_KEY_ALIAS
+                keyPassword MYAPP_RELEASE_KEY_PASSWORD
+            }
+        }
+    }
+        `;
+    if (appGradle.find("signingConfigs {") === -1) {
+      appGradle.insertBefore("buildTypes {", singinConfigBlock);
+    }
+    if (appGradle.find(`applicationIdSuffix ".debug"`) === -1) {
+      appGradle.insertAfter("buildTypes {", buildTypesBlock);
+    }
+    await appGradle.save();
+  }
+  async buildAndroid(assembleType: "apk" | "aab", options: { regenerate?: boolean } = {}) {
+    await this.prepareWww();
+    await this.#prepareAndroid(options);
+    await this.#updateAndroidBuildTypes();
+    
+    const isWindows = process.platform === "win32";
+    const gradleCommand = isWindows ? "gradlew.bat" : "./gradlew";
+
+    await this.app.spawn(gradleCommand, [assembleType === "apk" ? "assembleRelease" : "bundleRelease"], {
+      stdio: "inherit",
+      cwd: `${this.targetRoot}/android`,
+    });
+  }
+  async openAndroid() {
+    await this.#spawn("npx", ["cap", "open", "android"]);
+  }
+  async syncAndroid(options: { regenerate?: boolean } = {}) {
+    await this.prepareWww();
+    await this.#prepareAndroid(options);
+    this.app.log(`Sync Android Completed.`);
+  }
+  async runAndroid({ operation, env, regenerate = false }: RunConfig) {
+    if (operation === "release") await this.prepareWww();
+    await this.#prepareAndroid({ regenerate });
+    this.app.logger.info(`Running Android in ${operation} mode on ${env} env`);
+    const args = ["cap", "run", "android"];
+    if (operation !== "release") args.push("--live-reload");
+    await this.#spawn("npx", args, {
+      env: this.#commandEnv(operation, env),
+      stdio: "inherit",
+    });
+  }
+
+  async releaseIos() {
+    await this.prepareWww();
+    await this.#prepareIos();
+  }
+  async releaseAndroid() {
+    await this.prepareWww();
+    await this.#prepareAndroid();
+  }
+  async prepareWww() {
+    const htmlSource = path.join(this.app.dist.cwdPath, "csr", targetHtmlFilename(this.target));
+    if (!(await Bun.file(htmlSource).exists()))
+      throw new Error(`CSR html for mobile target '${this.target.name}' not found: ${htmlSource}`);
+    const wwwDir = path.join(this.targetRoot, "www");
+    await rm(wwwDir, { recursive: true, force: true });
+    await mkdir(wwwDir, { recursive: true });
+    await Bun.write(path.join(wwwDir, "index.html"), this.#injectMobileTargetMeta(await Bun.file(htmlSource).text()));
+  }
+  #injectMobileTargetMeta(html: string) {
+    const basePath = this.target.basePath?.replace(/^\/+|\/+$/g, "") ?? "";
+    const script = `<script>window.__AKAN_MOBILE_TARGET__=${JSON.stringify({ name: this.target.name, basePath })};</script>`;
+    if (html.includes("window.__AKAN_MOBILE_TARGET__")) return html;
+    return html.replace(/<\/head\s*>/i, `${script}\n</head>`);
+  }
+  async #writeCapacitorConfig() {
+    await mkdir(this.targetRoot, { recursive: true });
+    const appInfoPath = path
+      .relative(this.targetRoot, path.join(this.app.cwdPath, "akan.app.json"))
+      .split(path.sep)
+      .join("/");
+    const content = `import { withBase } from "akanjs/devkit/capacitor.base.config";
+import appInfo from "${appInfoPath}";
+
+export default withBase((config) => config, appInfo, "${this.target.name}");
+`;
+    await Bun.write(path.join(this.targetRoot, "capacitor.config.ts"), content);
+  }
+  async #prepareTargetAssets() {
+    if (!this.target.assets) return;
+    const assetsDir = path.join(this.targetRoot, "assets");
+    await mkdir(assetsDir, { recursive: true });
+    if (this.target.assets.icon)
+      await cp(path.join(this.app.cwdPath, this.target.assets.icon), path.join(assetsDir, "icon.png"), { force: true });
+    if (this.target.assets.splash)
+      await cp(path.join(this.app.cwdPath, this.target.assets.splash), path.join(assetsDir, "splash.png"), {
+        force: true,
+      });
+  }
+  async #prepareExternalFiles(platform: "ios" | "android") {
+    const files = this.target.files?.[platform];
+    if (!files) return;
+    await Promise.all(
+      Object.entries(files).map(async ([to, from]) => {
+        const targetPath = path.join(this.targetRoot, platform, to);
+        await mkdir(path.dirname(targetPath), { recursive: true });
+        await cp(path.join(this.app.cwdPath, from), targetPath, { force: true });
+      }),
+    );
+  }
+  async #generateAssets() {
+    if (!this.target.assets) return;
+    await this.#spawn("npx", ["@capacitor/assets", "generate"]);
+  }
+  async #applyIosMetadata() {
+    this.project.ios.setBundleId("App", "Debug", this.target.appId);
+    this.project.ios.setBundleId("App", "Release", this.target.appId);
+    await this.project.ios.setVersion("App", "Debug", this.target.version);
+    await this.project.ios.setVersion("App", "Release", this.target.version);
+    await this.project.ios.setBuild("App", "Debug", this.target.buildNum);
+    await this.project.ios.setBuild("App", "Release", this.target.buildNum);
+  }
+  async #applyAndroidMetadata() {
+    await this.project.android.setVersionName(this.target.version);
+    await this.project.android.setPackageName(this.target.appId);
+    await this.project.android.setVersionCode(this.target.buildNum);
+    await this.project.android.setAppName(this.target.appName);
+  }
+  async #applyPermissions() {
+    for (const permission of this.target.permissions ?? []) {
+      if (permission === "camera") await this.addCamera();
+      else if (permission === "contacts") await this.addContact();
+      else if (permission === "location") await this.addLocation();
+      else if (permission === "push") await this.addPush();
+    }
+  }
+  async #applyLinks() {
+    const links = this.target.links;
+    if (!links) return;
+    const schemes = links.schemes ?? [];
+    if (schemes.length > 0) {
+      await this.#setPermissionInIos({
+        appTransportSecurity: "",
+      });
+      for (const scheme of schemes) {
+        this.project.android
+          .getAndroidManifest()
+          .injectFragment(
+            "activity",
+            `<intent-filter><action android:name="android.intent.action.VIEW" /><category android:name="android.intent.category.DEFAULT" /><category android:name="android.intent.category.BROWSABLE" /><data android:scheme="${scheme}" /></intent-filter>`,
+          );
+      }
+    }
+    for (const domain of links.associatedDomains ?? []) {
+      this.app.logger.info(`Configure iOS associated domain manually if needed: ${domain}`);
+    }
+    for (const host of links.androidHosts ?? []) {
+      const pathPrefix = resolveMobilePath(this.target, "/");
+      this.project.android
+        .getAndroidManifest()
+        .injectFragment(
+          "activity",
+          `<intent-filter android:autoVerify="true"><action android:name="android.intent.action.VIEW" /><category android:name="android.intent.category.DEFAULT" /><category android:name="android.intent.category.BROWSABLE" /><data android:scheme="https" android:host="${host}" android:pathPrefix="${pathPrefix}" /></intent-filter>`,
+        );
+    }
+  }
+  #commandEnv(operation: "local" | "release", env: "local" | "debug" | "develop" | "main") {
+    return {
+      ...process.env,
+      APP_OPERATION_MODE: operation,
+      AKAN_PUBLIC_OPERATION_MODE: operation,
+      AKAN_PUBLIC_ENV: env,
+      AKAN_MOBILE_TARGET: this.target.name,
+    };
+  }
+  async #spawn(command: string, args: string[] = [], options: Parameters<AppExecutor["spawn"]>[2] = {}) {
+    return await this.app.spawn(command, args, { cwd: this.targetRoot, ...options });
+  }
+  async addCamera() {
+    await this.#setPermissionInIos({
+      cameraUsageDescription: "$(PRODUCT_NAME) requires access to the camera to take photos.",
+      photoAddUsageDescription: "$(PRODUCT_NAME) requires access to the photo library to take photos.",
+      photoUsageDescription: "$(PRODUCT_NAME) requires access to the photo library to take photos.",
+    });
+    this.#setPermissionsInAndroid(["READ_MEDIA_IMAGES", "READ_EXTERNAL_STORAGE", "WRITE_EXTERNAL_STORAGE"]);
+  }
+  async addContact() {
+    await this.#setPermissionInIos({
+      contactsUsageDescription: "$(PRODUCT_NAME) requires access to the contacts to add new contacts.",
+    });
+    this.#setPermissionsInAndroid(["READ_CONTACTS", "WRITE_CONTACTS"]);
+  }
+  async addLocation() {
+    await this.#setPermissionInIos({
+      locationAlwaysUsageDescription: "$(PRODUCT_NAME) requires access to the location to get the user's location.",
+      locationWhenInUseUsageDescription: "$(PRODUCT_NAME) requires access to the location to get the user's location.",
+    });
+    this.#setPermissionsInAndroid(["ACCESS_COARSE_LOCATION", "ACCESS_FINE_LOCATION"]);
+    this.#setFeaturesInAndroid(["android.hardware.location.gps"]);
+  }
+  async addPush() {
+    await this.#setPermissionInIos({
+      userNotificationsUsageDescription: "$(PRODUCT_NAME) uses notifications to keep you updated.",
+    });
+    this.#setPermissionsInAndroid(["POST_NOTIFICATIONS"]);
+  }
+  async #setPermissionInIos(permissions: { [key: string]: string }) {
+    const updateNs = Object.fromEntries(
+      Object.entries(permissions).map(([key, value]) => [`NS${capitalize(key)}`, value]),
+    );
+    await Promise.all([
+      this.project.ios.updateInfoPlist(this.iosTargetName, "Debug", updateNs),
+      this.project.ios.updateInfoPlist(this.iosTargetName, "Release", updateNs),
+    ]);
+  }
+  #setFeaturesInAndroid(features: string[]) {
+    for (const feature of features) {
+      if (this.#hasFeatureInAndroid(feature)) {
+        this.app.logger.info(`${feature} already exists in android`);
+        return this;
+      }
+      this.app.logger.info(`Adding ${feature} to android`);
+      this.project.android
+        .getAndroidManifest()
+        .injectFragment("manifest", `<uses-feature android:name="${feature}" />`);
+    }
+    return this;
+  }
+  #getFeaturesInAndroid() {
+    const androidManifest = this.project.android.getAndroidManifest();
+    const element = androidManifest.getDocumentElement();
+    if (!element) throw new Error("manifest not found");
+    const usesFeature = element.getElementsByTagName("uses-feature");
+    return Array.from(usesFeature).map((feature) => feature.getAttribute("android:name"));
+  }
+  #hasFeatureInAndroid(feature: string) {
+    return this.#getFeaturesInAndroid().includes(feature);
+  }
+
+  #setPermissionsInAndroid(permissions: string[]) {
+    for (const permission of permissions) {
+      if (this.#hasPermissionInAndroid(permission)) {
+        this.app.logger.info(`${permission} already exists in android`);
+        return this;
+      }
+      this.app.logger.info(`Adding ${permission} to android`);
+      this.project.android
+        .getAndroidManifest()
+        .injectFragment("manifest", `<uses-permission android:name="android.permission.${permission}" />`);
+    }
+    return this;
+  }
+  #getPermissionsInAndroid() {
+    const androidManifest = this.project.android.getAndroidManifest();
+    const element = androidManifest.getDocumentElement();
+    if (!element) throw new Error("manifest not found");
+    const usesPermission = element.getElementsByTagName("uses-permission");
+    return Array.from(usesPermission).map((permission) => permission.getAttribute("android:name"));
+  }
+  #hasPermissionInAndroid(permission: string) {
+    return this.#getPermissionsInAndroid().includes(permission);
+  }
+}

package/devkit/commandDecorators/argMeta.ts

@@ -0,0 +1,88 @@
+import type {
+  AppExecutor,
+  Executor,
+  LibExecutor,
+  ModuleExecutor,
+  PkgExecutor,
+  SysExecutor,
+  WorkspaceExecutor,
+} from "../executors";
+import { COMMAND_META, type CommandCls } from "./targetMeta";
+
+export const argTypes = ["Argument", "Option"] as const;
+export type ArgType = (typeof argTypes)[number];
+
+export const internalArgTypes = ["Workspace", "App", "Lib", "Sys", "Pkg", "Module", "Exec"] as const;
+export type InternalArgType = (typeof internalArgTypes)[number];
+
+export type PrimitiveArgType = StringConstructor | NumberConstructor | BooleanConstructor;
+export type NormalizedPrimitiveArgType = "string" | "number" | "boolean";
+
+export interface ArgsOption {
+  type?: "string" | "number" | "boolean";
+  flag?: string;
+  desc?: string;
+  default?: string | number | boolean;
+  nullable?: boolean;
+  example?: string | number | boolean;
+  enum?: (string | number)[] | readonly (string | number)[] | { label: string; value: string | number | boolean }[];
+  ask?: string;
+}
+export interface ArgMeta {
+  name: string;
+  argsOption: ArgsOption;
+  key: string;
+  idx: number;
+  type: ArgType;
+}
+export interface InternalArgMeta {
+  key: string;
+  idx: number;
+  type: InternalArgType;
+  option?: { nullable?: boolean };
+}
+
+export const getArgMetas = (
+  command: CommandCls,
+  key: string,
+): [(ArgMeta | InternalArgMeta)[], ArgMeta[], (ArgMeta | InternalArgMeta)[]] => {
+  const allArgMetas = [...(command[COMMAND_META]?.get(key)?.args ?? [])];
+  const argMetas = allArgMetas.filter((argMeta): argMeta is ArgMeta => argMeta.type === "Option");
+  const internalArgMetas = allArgMetas.filter((argMeta) => argMeta.type !== "Option");
+  return [allArgMetas, argMetas, internalArgMetas];
+};
+
+export interface InternalArgToken<T = unknown> {
+  type: InternalArgType;
+  _value: T;
+}
+
+const createInternalArgToken = <T>(type: InternalArgType) => ({ type }) as InternalArgToken<T>;
+
+export const normalizePrimitiveArgType = (type: PrimitiveArgType): NormalizedPrimitiveArgType => {
+  if (type === String) return "string";
+  if (type === Number) return "number";
+  if (type === Boolean) return "boolean";
+  throw new Error(`Invalid primitive argument type: ${type}`);
+};
+
+export const App = createInternalArgToken<AppExecutor>("App");
+export type App = AppExecutor;
+
+export const Lib = createInternalArgToken<LibExecutor>("Lib");
+export type Lib = LibExecutor;
+
+export const Sys = createInternalArgToken<SysExecutor>("Sys");
+export type Sys = SysExecutor;
+
+export const Exec = createInternalArgToken<Executor>("Exec");
+export type Exec = Executor;
+
+export const Pkg = createInternalArgToken<PkgExecutor>("Pkg");
+export type Pkg = PkgExecutor;
+
+export const Module = createInternalArgToken<ModuleExecutor>("Module");
+export type Module = ModuleExecutor;
+
+export const Workspace = createInternalArgToken<WorkspaceExecutor>("Workspace");
+export type Workspace = WorkspaceExecutor;