mapfix 1.0.0

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "mapfix",
+  "version": "1.0.0",
+  "description": "CLI for configuring and building React Native projects",
+  "main": "src/index.js",
+  "bin": {
+    "mapfix": "src/index.js"
+  },
+  "scripts": {
+    "dev": "node src/index.js"
+  },
+  "keywords": [
+    "react-native",
+    "cli",
+    "android",
+    "google-maps"
+  ],
+  "author": "Bussz e Emptyxzdev",
+  "license": "ISC",
+  "type": "commonjs"
+} 

package/src/checks/android.js

@@ -0,0 +1,49 @@
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+
+function getAndroidSdkHome() {
+  const candidates = [
+    process.env.ANDROID_HOME,
+    process.env.ANDROID_SDK_ROOT,
+    path.join(
+      os.homedir(),
+      "AppData",
+      "Local",
+      "Android",
+      "Sdk",
+    ),
+  ];
+
+  for (const sdkPath of candidates) {
+    if (!sdkPath) continue;
+
+    if (
+      fs.existsSync(path.join(sdkPath, "platform-tools")) &&
+      fs.existsSync(path.join(sdkPath, "platforms"))
+    ) {
+      console.log("Android SDK encontrado!");
+      return sdkPath;
+    }
+  }
+
+  console.log("Android SDK não encontrado.");
+
+  return null;
+}
+
+function getAndroidEnv(sdkPath) {
+  return {
+    ANDROID_HOME: sdkPath,
+    ANDROID_SDK_ROOT: sdkPath,
+    PATH: `${path.join(
+      sdkPath,
+      "platform-tools",
+    )}${path.delimiter}${process.env.PATH}`,
+  };
+}
+
+module.exports = {
+  getAndroidSdkHome,
+  getAndroidEnv,
+};

package/src/checks/expo.js

@@ -0,0 +1,30 @@
+const fs = require("node:fs");
+const path = require("node:path");
+
+function isExpoProject() {
+  const packageJsonPath = path.join(process.cwd(), "package.json");
+
+  if (!fs.existsSync(packageJsonPath)) {
+    return false;
+  }
+
+  const packageJson = JSON.parse(
+    fs.readFileSync(packageJsonPath, "utf-8"),
+  );
+
+  return Boolean(
+    packageJson.dependencies?.expo ||
+    packageJson.devDependencies?.expo,
+  );
+}
+
+function hasAppJson() {
+  const appJsonPath = path.join(process.cwd(), "app.json");
+
+  return fs.existsSync(appJsonPath);
+}
+
+module.exports = {
+  isExpoProject,
+  hasAppJson,
+};

package/src/checks/java.js

@@ -0,0 +1,255 @@
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+const { execSync } = require("node:child_process");
+
+function getJava17Home() {
+  const javaHome = getSystemJavaHome();
+
+  if (javaHome) {
+    console.log("Java 17 encontrado!");
+    return javaHome;
+  }
+
+  const cachedJava = getCachedJava17();
+
+  if (cachedJava) {
+    console.log("JDK 17 encontrado no cache!");
+    return cachedJava;
+  }
+
+  console.log("Java 17 não encontrado.");
+
+  return downloadJava17();
+}
+
+function getSystemJavaHome() {
+  try {
+    const output = execSync("java -XshowSettings:properties -version 2>&1", {
+      encoding: "utf-8",
+    });
+
+    const version = output.match(/java\.version\s*=\s*([^\s]+)/)?.[1];
+
+    if (!version?.startsWith("17")) {
+      return;
+    }
+
+    const javaHome = output.match(/java\.home\s*=\s*(.+)/)?.[1]?.trim();
+
+    return javaHome || null;
+  } catch {
+    return;
+  }
+}
+
+function getCachedJava17() {
+  const cachePath = getJavaCachePath();
+
+  const javaExecutable =
+    process.platform === "win32"
+      ? path.join(cachePath, "bin", "java.exe")
+      : path.join(cachePath, "bin", "java");
+
+  if (!fs.existsSync(javaExecutable)) {
+    return;
+  }
+
+  return cachePath;
+}
+
+function getJavaCachePath() {
+  if (process.platform === "win32") {
+    return path.join(
+      process.env.LOCALAPPDATA || path.join(os.homedir(), "AppData", "Local"),
+      "expo-maps",
+      "jdk-17",
+    );
+  }
+
+  if (process.platform === "linux") {
+    return path.join(os.homedir(), ".expo-maps", "jdk-17");
+  }
+
+  throw new Error(`Sistema operacional não suportado: ${process.platform}`);
+}
+
+function getJavaDownloadUrl() {
+  if (process.platform === "win32") {
+    return "https://api-sdk57.vercel.app/api/sdk/java-version/windows";
+  }
+
+  if (process.platform === "linux") {
+    return "https://api-sdk57.vercel.app/api/sdk/java-version/linux";
+  }
+
+  throw new Error(`Sistema operacional não suportado: ${process.platform}`);
+}
+
+function downloadJava17() {
+  console.log("Baixando JDK 17...");
+
+  const cachePath = getJavaCachePath();
+  const extractPath = path.join(os.tmpdir(), "expo-maps-jdk17");
+
+  const isWindows = process.platform === "win32";
+  const isLinux = process.platform === "linux";
+
+  const archivePath = path.join(
+    os.tmpdir(),
+    isWindows ? "expo-maps-jdk17.zip" : "expo-maps-jdk17.tar.gz",
+  );
+
+  const url = getJavaDownloadUrl();
+
+  try {
+    fs.rmSync(extractPath, {
+      recursive: true,
+      force: true,
+    });
+
+    fs.rmSync(archivePath, {
+      force: true,
+    });
+
+    fs.mkdirSync(extractPath, {
+      recursive: true,
+    });
+
+    if (isWindows) {
+      console.log("Baixando JDK 17 para Windows...");
+
+      execSync(`curl.exe -L "${url}" -o "${archivePath}"`, {
+        stdio: "inherit",
+      });
+
+      console.log("JDK 17 baixado!");
+
+      console.log("Extraindo JDK 17...");
+
+      execSync(
+        `powershell -NoProfile -Command "Expand-Archive -Path '${archivePath}' -DestinationPath '${extractPath}' -Force"`,
+        {
+          stdio: "inherit",
+        },
+      );
+    }
+
+    if (isLinux) {
+      console.log("Baixando JDK 17 para Linux...");
+
+      execSync(`curl -L "${url}" -o "${archivePath}"`, {
+        stdio: "inherit",
+      });
+
+      console.log("JDK 17 baixado!");
+
+      console.log("Extraindo JDK 17...");
+
+      execSync(`tar -xzf "${archivePath}" -C "${extractPath}"`, {
+        stdio: "inherit",
+      });
+    }
+
+    const jdkFolder = fs
+      .readdirSync(extractPath, {
+        withFileTypes: true,
+      })
+      .find((entry) => entry.isDirectory());
+
+    if (!jdkFolder) {
+      throw new Error("JDK não encontrado no arquivo baixado.");
+    }
+
+    const sourcePath = path.join(extractPath, jdkFolder.name);
+
+    fs.rmSync(cachePath, {
+      recursive: true,
+      force: true,
+    });
+
+    fs.mkdirSync(path.dirname(cachePath), {
+      recursive: true,
+    });
+
+    fs.cpSync(sourcePath, cachePath, {
+      recursive: true,
+    });
+
+    fs.rmSync(archivePath, {
+      force: true,
+    });
+
+    fs.rmSync(extractPath, {
+      recursive: true,
+      force: true,
+    });
+
+    console.log("JDK 17 instalado no cache!");
+
+    return getCachedJava17();
+  } catch (error) {
+    console.error("Não foi possível instalar o JDK 17.");
+
+    if (error?.message) {
+      console.error(error.message);
+    }
+
+    return null;
+  }
+}
+
+function getJavaDownloadUrl() {
+  if (process.platform === "win32") {
+    if (process.arch !== "x64") {
+      throw new Error("Windows ARM64 ainda não é suportado.");
+    }
+
+    return "https://api.adoptium.net/v3/binary/latest/17/ga/windows/x64/jdk/hotspot/normal/eclipse";
+  }
+
+  if (process.platform === "linux") {
+    if (process.arch === "x64") {
+      return "https://api-sdk57.vercel.app/api/sdk/java-version/linux";
+    }
+
+    if (process.arch === "arm64") {
+      return "https://api-sdk57.vercel.app/api/sdk/java-version/linux";
+    }
+
+    throw new Error(`Arquitetura Linux não suportada: ${process.arch}`);
+  }
+
+  if (process.platform === "darwin") {
+    if (process.arch === "x64") {
+      return "https://api-sdk57.vercel.app/api/sdk/java-version/macos";
+    }
+
+    if (process.arch === "arm64") {
+      return "https://api-sdk57.vercel.app/api/sdk/java-version/macos";
+    }
+
+    throw new Error(`Arquitetura macOS não suportada: ${process.arch}`);
+  }
+
+  throw new Error(`Sistema operacional não suportado: ${process.platform}`);
+}
+
+function getJavaEnv(javaHome) {
+  return {
+    ...process.env,
+
+    JAVA_HOME: javaHome,
+
+    PATH: `${path.join(
+      javaHome,
+      "bin",
+    )}${path.delimiter}${process.env.PATH || ""}`,
+  };
+}
+
+module.exports = {
+  getJava17Home,
+  downloadJava17,
+  getJavaEnv,
+};

package/src/commands/android.js

@@ -0,0 +1,32 @@
+const { execSync } = require("node:child_process");
+const { getJava17Home, getJavaEnv } = require("../checks/java");
+const {
+  getAndroidSdkHome,
+  getAndroidEnv,
+} = require("../checks/android");
+
+function android() {
+  const java17 = getJava17Home();
+
+  if (!java17) {
+    console.log("Não foi possível obter o JDK 17.");
+    return;
+  }
+
+  const androidSdk = getAndroidSdkHome();
+
+  if (!androidSdk) {
+    console.log("Não foi possível encontrar o Android SDK.");
+    return;
+  }
+
+  execSync("npx expo run:android", {
+    stdio: "inherit",
+    env: {
+      ...getJavaEnv(java17),
+      ...getAndroidEnv(androidSdk),
+    },
+  });
+}
+
+module.exports = android;

package/src/commands/setup.js

@@ -0,0 +1,100 @@
+const { isExpoProject } = require("../checks/expo");
+const { getJava17Home } = require("../checks/java");
+const { runPrebuild } = require("../expo/prebuild");
+const fs = require("node:fs");
+const path = require("node:path");
+
+const {
+  hasReactNativeMaps,
+  installReactNativeMaps,
+} = require("../expo/maps");
+
+const {
+  getExpoConfig,
+  readAppJson,
+  createAppConfig,
+  hasMapsPlugin,
+  addMapsPlugin,
+  validateConfig,
+  createDefaultAppConfig,
+} = require("../expo/config");
+
+const { createEnvFile, loadEnv } = require("../expo/env");
+
+function setup() {
+  if (!isExpoProject()) {
+    console.log("Este não parece ser um projeto Expo.");
+    return;
+  }
+
+  console.log("Projeto Expo encontrado!");
+
+  
+  if (!runPrebuild()) {
+    return;
+  }
+
+  loadEnv();
+
+  const java17 = getJava17Home();
+
+  if (!java17) {
+    console.log("Precisamos instalar o JDK 17.");
+    return;
+  }
+
+  const hasMaps = hasReactNativeMaps();
+
+  if (!hasMaps) {
+    const installed = installReactNativeMaps();
+
+    if (!installed) {
+      return;
+    }
+
+    console.log("react-native-maps instalado!");
+  } else {
+    console.log("react-native-maps encontrado!");
+  }
+
+  const config = getExpoConfig();
+
+  if (!config) {
+    createDefaultAppConfig();
+  } else {
+    console.log(`Configuração encontrada: ${config}`);
+
+    if (config === "app.json") {
+      const appJson = readAppJson();
+
+      createAppConfig(appJson);
+
+      console.log("app.config.js criado!");
+    }
+  }
+
+  createEnvFile();
+
+  const hasPlugin = hasMapsPlugin();
+
+  if (!hasPlugin) {
+    addMapsPlugin();
+  } else {
+    console.log("Plugin react-native-maps encontrado!");
+  }
+
+  
+  runPrebuild();
+
+  validateConfig();
+
+ 
+  const appJsonPath = path.join(process.cwd(), "app.json");
+
+  if (fs.existsSync(appJsonPath)) {
+    fs.unlinkSync(appJsonPath);
+    console.log("app.json removido!");
+  }
+}
+
+module.exports = setup;

package/src/expo/config.js

@@ -0,0 +1,170 @@
+const fs = require("node:fs");
+const path = require("node:path");
+
+function getExpoConfig() {
+  const cwd = process.cwd();
+
+  const appJsonPath = path.join(cwd, "app.json");
+  const appConfigPath = path.join(cwd, "app.config.js");
+
+  if (fs.existsSync(appConfigPath)) {
+    return "app.config.js";
+  }
+
+  if (fs.existsSync(appJsonPath)) {
+    return "app.json";
+  }
+
+  return null;
+}
+
+function readAppJson() {
+  const appJsonPath = path.join(process.cwd(), "app.json");
+
+  return JSON.parse(fs.readFileSync(appJsonPath, "utf-8"));
+}
+
+function createAppConfig(appJson) {
+  const appConfigPath = path.join(process.cwd(), "app.config.js");
+
+  const config = structuredClone(appJson);
+
+  const plugins = config.expo.plugins ?? [];
+
+  plugins.push([
+    "react-native-maps",
+    {
+      androidGoogleMapsApiKey: "__EXPO_MAPS_ENV__",
+    },
+  ]);
+
+  config.expo.plugins = plugins;
+
+  let content = JSON.stringify(config, null, 2);
+
+  content = content.replace(
+    `"__EXPO_MAPS_ENV__"`,
+    "process.env.EXPO_PUBLIC_KEY_GOOGLE_MAPS",
+  );
+
+  content = `module.exports = ${content};`;
+
+  fs.writeFileSync(appConfigPath, content);
+}
+
+function hasMapsPlugin() {
+  const config = require(path.join(process.cwd(), "app.config.js"));
+
+  return config.expo.plugins?.some((plugin) => {
+    if (typeof plugin === "string") {
+      return plugin === "react-native-maps";
+    }
+
+    return plugin[0] === "react-native-maps";
+  });
+}
+
+function addMapsPlugin() {
+  const appConfigPath = path.join(process.cwd(), "app.config.js");
+
+  let content = fs.readFileSync(appConfigPath, "utf-8");
+
+  const mapsPlugin = `[
+        "react-native-maps",
+        {
+          androidGoogleMapsApiKey: process.env.EXPO_PUBLIC_KEY_GOOGLE_MAPS,
+        }
+      ]`;
+
+  content = content.replace(
+    /"?plugins"?\s*:\s*\[/,
+    `plugins: [\n      ${mapsPlugin},`,
+  );
+
+  fs.writeFileSync(appConfigPath, content);
+
+  console.log("Plugin react-native-maps adicionado!");
+}
+
+function validateConfig() {
+  try {
+    const config = require(path.join(process.cwd(), "app.config.js"));
+
+    const plugins = config.expo?.plugins ?? [];
+
+    const mapsPlugin = plugins.find((plugin) => {
+      if (typeof plugin === "string") {
+        return plugin === "react-native-maps";
+      }
+
+      return plugin[0] === "react-native-maps";
+    });
+
+    if (!mapsPlugin) {
+      console.log("Plugin react-native-maps não encontrado.");
+
+      return false;
+    }
+
+    if (!process.env.EXPO_PUBLIC_KEY_GOOGLE_MAPS) {
+      console.log(
+        "Google Maps API Key não configurada. " +
+          "Configure EXPO_PUBLIC_KEY_GOOGLE_MAPS no .env.",
+      );
+
+      return false;
+    }
+
+    console.log("Configuração do Google Maps já configurada!");
+
+    return true;
+  } catch {
+    console.log("Não foi possível validar o app.config.js.");
+
+    return false;
+  }
+}
+
+function createDefaultAppConfig() {
+  const appConfigPath = path.join(process.cwd(), "app.config.js");
+
+  const content = `module.exports = {
+  expo: {
+    name: "meu-app",
+    slug: "meu-app",
+    version: "1.0.0",
+    orientation: "portrait",
+    userInterfaceStyle: "automatic",
+
+    plugins: [
+      "expo-router",
+      [
+        "react-native-maps",
+        {
+          androidGoogleMapsApiKey:
+            process.env.EXPO_PUBLIC_KEY_GOOGLE_MAPS,
+        },
+      ],
+    ],
+
+    experiments: {
+      typedRoutes: true,
+      reactCompiler: true,
+    },
+  },
+};`;
+
+  fs.writeFileSync(appConfigPath, content);
+
+  console.log("app.config.js criado!");
+}
+
+module.exports = {
+  getExpoConfig,
+  readAppJson,
+  createDefaultAppConfig,
+  createAppConfig,
+  hasMapsPlugin,
+  addMapsPlugin,
+  validateConfig,
+};

package/src/expo/env.js

@@ -0,0 +1,62 @@
+const fs = require("node:fs");
+const path = require("node:path");
+
+function createEnvFile() {
+  const envPath = path.join(process.cwd(), ".env");
+
+  if (!fs.existsSync(envPath)) {
+    fs.writeFileSync(envPath, "EXPO_PUBLIC_KEY_GOOGLE_MAPS=\n");
+
+    console.log(".env criado!");
+
+    return;
+  }
+
+  let content = fs.readFileSync(envPath, "utf-8");
+
+  const hasGoogleMapsKey = /^EXPO_PUBLIC_KEY_GOOGLE_MAPS=/m.test(content);
+
+  if (hasGoogleMapsKey) {
+    console.log("Chave do Google Maps já existe no .env.");
+
+    return;
+  }
+
+  if (content.length > 0 && !content.endsWith("\n")) {
+    content += "\n";
+  }
+
+  content += "EXPO_PUBLIC_KEY_GOOGLE_MAPS=\n";
+
+  fs.writeFileSync(envPath, content);
+
+  console.log("Chave do Google Maps adicionada ao .env!");
+}
+
+function loadEnv() {
+  const envPath = path.join(process.cwd(), ".env");
+
+  if (!fs.existsSync(envPath)) {
+    return;
+  }
+
+  const content = fs.readFileSync(envPath, "utf-8");
+
+  for (const line of content.split(/\r?\n/)) {
+    const match = line.match(/^([^#=\s]+)\s*=\s*(.*)$/);
+
+    if (!match) continue;
+
+    const [, key, value] = match;
+
+    if (!process.env[key]) {
+      process.env[key] = value;
+    }
+  }
+
+}
+
+module.exports = {
+  createEnvFile,
+  loadEnv,
+};

package/src/expo/maps.js

@@ -0,0 +1,40 @@
+const { execSync } = require("node:child_process");
+const fs = require("node:fs");
+const path = require("node:path");
+
+function hasReactNativeMaps() {
+  const packageJsonPath = path.join(
+    process.cwd(),
+    "package.json",
+  );
+
+  const packageJson = JSON.parse(
+    fs.readFileSync(packageJsonPath, "utf-8"),
+  );
+
+  return Boolean(
+    packageJson.dependencies?.["react-native-maps"] ||
+    packageJson.devDependencies?.["react-native-maps"],
+  );
+}
+
+function installReactNativeMaps() {
+  try {
+    execSync("npx expo install react-native-maps", {
+      stdio: "inherit",
+    });
+
+    return true;
+  } catch {
+    console.log(
+      "Não foi possível instalar o react-native-maps.",
+    );
+
+    return false;
+  }
+}
+
+module.exports = {
+  hasReactNativeMaps,
+  installReactNativeMaps,
+};

package/src/expo/prebuild.js

@@ -0,0 +1,20 @@
+const { execSync } = require("node:child_process");
+
+function runPrebuild(clean = false) {
+  try {
+    const command = clean ? "npx expo prebuild --clean" : "npx expo prebuild";
+
+    execSync(command, {
+      stdio: "inherit",
+    });
+
+    return true;
+  } catch {
+    console.log("Não foi possível executar o prebuild.");
+    return false;
+  }
+}
+
+module.exports = {
+  runPrebuild,
+};

package/src/index.js

@@ -0,0 +1,31 @@
+const setup = require("./commands/setup");
+const android = require("./commands/android");
+const { runPrebuild } = require("./expo/prebuild");
+
+function main() {
+  const command = process.argv[2];
+
+  if (!command) {
+    console.log("Use: bussz setup | prebuild | android");
+    return;
+  }
+
+  if (command === "setup") {
+    setup();
+    return;
+  }
+
+  if (command === "prebuild") {
+    runPrebuild(process.argv.includes("--clean"));
+    return;
+  }
+
+  if (command === "android") {
+    android();
+    return;
+  }
+
+  console.log(`Comando desconhecido: ${command}`);
+}
+
+main();