@highbeek/create-rnstarterkit 1.0.2-beta.11 → 1.0.2-beta.13

package/dist/src/generators/appGenerator.js

@@ -8,7 +8,7 @@ const path_1 = __importDefault(require("path"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const execa_1 = require("execa");
 async function generateApp(options) {
-    const { platform, projectName, auth, apiClient, absoluteImports, state, dataFetching, validation, storage, typescript, apiClientType, husky, } = options;
+    const { platform, projectName, auth, apiClient, absoluteImports, state, dataFetching, validation, storage, typescript, apiClientType, husky, sentry, i18n, maestro, } = options;
     const templateRoot = await resolveTemplateRoot();
     const templateFolder = platform === "Expo" ? "expo-base" : "cli-base";
     const templatePath = path_1.default.join(templateRoot, templateFolder);
@@ -21,7 +21,7 @@ async function generateApp(options) {
     if (platform === "React Native CLI") {
         await configureCliNativeProjectNames(targetPath, projectName);
     }
-    await createStandardStructure(targetPath, platform);
+    await createStandardStructure(targetPath, platform, state);
     if (auth) {
         const authFolder = state === "Redux Toolkit"
             ? "auth-redux"
@@ -73,18 +73,23 @@ async function generateApp(options) {
     await configureTesting(targetPath);
     await configureNavigationTypes(targetPath, { platform, auth, state });
     await configureEnv(targetPath, platform);
-    await stampVersion(targetPath);
+    await configureVSCode(targetPath);
+    if (sentry)
+        await configureSentry(targetPath, platform);
+    if (i18n)
+        await configureI18n(targetPath, platform);
+    if (maestro)
+        await configureMaestro(targetPath, { auth, ci: options.ci });
+    await stampVersion(targetPath, options);
     if (options.ci)
         await configureCi(targetPath);
     if (husky)
         await configureHusky(targetPath);
     if (typescript) {
-        const tsconfigTemplate = path_1.default.join(templateRoot, "optional/tsconfig.json");
-        if (await fs_extra_1.default.pathExists(tsconfigTemplate)) {
-            await fs_extra_1.default.copy(tsconfigTemplate, path_1.default.join(targetPath, "tsconfig.json"), {
-                overwrite: true,
-            });
-        }
+        // Rename App.js -> App.tsx for projects generated without a .tsx entry point.
+        // Both cli-base and expo-base templates already ship App.tsx and correct
+        // tsconfigs (extending @react-native/typescript-config / expo/tsconfig.base),
+        // so we must NOT overwrite those configs here.
         const appJs = path_1.default.join(targetPath, "App.js");
         const appTsx = path_1.default.join(targetPath, "App.tsx");
         if (await fs_extra_1.default.pathExists(appJs)) {
@@ -231,7 +236,7 @@ async function ensureCliApiEnvSupport(targetPath) {
         },
     });
 }
-async function createStandardStructure(targetPath, platform) {
+async function createStandardStructure(targetPath, platform, state) {
     const commonDirectories = [
         "assets",
         "assets/icons",
@@ -243,11 +248,14 @@ async function createStandardStructure(targetPath, platform) {
         "services",
         "api",
         "config",
-        "context",
         "theme",
         "providers",
         "types",
     ];
+    // Only scaffold a context/ dir when Context API is the chosen state solution
+    if (state === "Context API" || state === "None") {
+        commonDirectories.push("context");
+    }
     const cliOnlyDirectories = ["navigation", "screens"];
     const directories = platform === "Expo"
         ? commonDirectories
@@ -2253,7 +2261,7 @@ async function configureTesting(targetPath) {
         }
     }
 }
-async function stampVersion(targetPath) {
+async function stampVersion(targetPath, options) {
     const packageJsonPath = path_1.default.join(targetPath, "package.json");
     if (!(await fs_extra_1.default.pathExists(packageJsonPath)))
         return;
@@ -2274,9 +2282,158 @@ async function stampVersion(targetPath) {
         }
     }
     const projectPkg = await fs_extra_1.default.readJson(packageJsonPath);
-    projectPkg.rnstarterkit = cliVersion;
+    // Save full config so `generate` subcommand can read project context
+    projectPkg.rnstarterkitConfig = {
+        version: cliVersion,
+        platform: options.platform,
+        state: options.state,
+        auth: options.auth,
+        dataFetching: options.dataFetching,
+        storage: options.storage,
+        apiClient: options.apiClient,
+        sentry: options.sentry,
+        i18n: options.i18n,
+        maestro: options.maestro,
+    };
     await fs_extra_1.default.writeJson(packageJsonPath, projectPkg, { spaces: 2 });
 }
+async function configureVSCode(targetPath) {
+    await writeIfMissing(path_1.default.join(targetPath, ".vscode", "extensions.json"), JSON.stringify({
+        recommendations: [
+            "dbaeumer.vscode-eslint",
+            "esbenp.prettier-vscode",
+            "msjsdiag.vscode-react-native",
+            "orta.vscode-jest",
+            "pflannery.vscode-versionlens",
+        ],
+    }, null, 2) + "\n");
+    await writeIfMissing(path_1.default.join(targetPath, ".vscode", "settings.json"), JSON.stringify({
+        "editor.formatOnSave": true,
+        "editor.defaultFormatter": "esbenp.prettier-vscode",
+        "editor.codeActionsOnSave": {
+            "source.fixAll.eslint": "explicit",
+        },
+        "typescript.preferences.importModuleSpecifier": "relative",
+        "typescript.tsdk": "node_modules/typescript/lib",
+        "emmet.includeLanguages": { typescript: "javascript" },
+        "files.exclude": {
+            "**/.git": true,
+            "**/node_modules": true,
+            "ios/Pods": true,
+            "android/.gradle": true,
+        },
+    }, null, 2) + "\n");
+}
+async function configureSentry(targetPath, platform) {
+    await ensureDependencies(targetPath, {
+        dependencies: { "@sentry/react-native": "^6.4.0" },
+    });
+    // Write platform-aware sentry.ts — DSN is read from env, never hardcoded
+    const isExpo = platform === "Expo";
+    const dsnVar = isExpo ? "process.env.EXPO_PUBLIC_SENTRY_DSN" : "Config.SENTRY_DSN";
+    const dsnImport = isExpo
+        ? ""
+        : `import Config from 'react-native-config';\n`;
+    const sentryContent = `${dsnImport}import * as Sentry from '@sentry/react-native';
+
+export function initSentry() {
+  const dsn = ${dsnVar};
+  if (!dsn) {
+    console.warn('[Sentry] DSN not set. Add ${isExpo ? "EXPO_PUBLIC_SENTRY_DSN" : "SENTRY_DSN"} to your .env file.');
+    return;
+  }
+  Sentry.init({
+    dsn,
+    tracesSampleRate: 1.0,
+    debug: __DEV__,
+    attachStacktrace: true,
+    environment: __DEV__ ? 'development' : 'production',
+  });
+}
+
+/** Manually capture an exception (e.g. in a catch block) */
+export function captureException(error: unknown) {
+  Sentry.captureException(error);
+}
+
+/** Add a breadcrumb for tracing user flows */
+export function addBreadcrumb(message: string, category = 'app') {
+  Sentry.addBreadcrumb({ message, category });
+}
+`;
+    await writeIfMissing(path_1.default.join(targetPath, "src", "utils", "sentry.ts"), sentryContent);
+    // Add SENTRY_DSN to .env.example so devs know where to put it
+    const envExamplePath = path_1.default.join(targetPath, ".env.example");
+    if (await fs_extra_1.default.pathExists(envExamplePath)) {
+        const envContent = await fs_extra_1.default.readFile(envExamplePath, "utf8");
+        const sentryKey = isExpo ? "EXPO_PUBLIC_SENTRY_DSN" : "SENTRY_DSN";
+        if (!envContent.includes(sentryKey)) {
+            await fs_extra_1.default.appendFile(envExamplePath, `\n# Sentry — get your DSN from https://sentry.io → Project Settings → Client Keys\n${sentryKey}=\n`);
+        }
+    }
+    // Inject initSentry into app entry point
+    const entryFile = isExpo
+        ? path_1.default.join(targetPath, "app", "_layout.tsx")
+        : path_1.default.join(targetPath, "App.tsx");
+    if (await fs_extra_1.default.pathExists(entryFile)) {
+        let content = await fs_extra_1.default.readFile(entryFile, "utf8");
+        if (!content.includes("initSentry")) {
+            content = content.replace(/^(import .+\n)+/m, (match) => `${match}import { initSentry } from '../src/utils/sentry';\n`);
+            content = content.replace(/(export default|function )/, `initSentry();\n\n$1`);
+            await fs_extra_1.default.writeFile(entryFile, content, "utf8");
+        }
+    }
+    console.log(`➕ Sentry configured. Add your DSN to .env:\n   ${isExpo ? "EXPO_PUBLIC_SENTRY_DSN" : "SENTRY_DSN"}=https://...@sentry.io/...`);
+}
+async function configureI18n(targetPath, platform) {
+    await copyOptionalModule("i18n", targetPath);
+    await ensureDependencies(targetPath, {
+        dependencies: {
+            i18next: "^24.2.0",
+            "react-i18next": "^15.4.0",
+            "react-native-localize": "^3.4.0",
+        },
+    });
+    // Inject i18n import into app entry so it initialises before first render
+    const entryFile = platform === "Expo"
+        ? path_1.default.join(targetPath, "app", "_layout.tsx")
+        : path_1.default.join(targetPath, "App.tsx");
+    if (await fs_extra_1.default.pathExists(entryFile)) {
+        let content = await fs_extra_1.default.readFile(entryFile, "utf8");
+        if (!content.includes("i18n/i18n")) {
+            // Add as first import so i18next is ready before any component renders
+            content = `import '../src/i18n/i18n';\n${content}`;
+            await fs_extra_1.default.writeFile(entryFile, content, "utf8");
+        }
+    }
+}
+async function configureMaestro(targetPath, options) {
+    await copyOptionalModule(options.auth ? "maestro-auth" : "maestro", targetPath);
+    // Extend CI workflow with a maestro job if CI was also selected
+    if (options.ci) {
+        const ciPath = path_1.default.join(targetPath, ".github", "workflows", "ci.yml");
+        if (await fs_extra_1.default.pathExists(ciPath)) {
+            const content = await fs_extra_1.default.readFile(ciPath, "utf8");
+            if (!content.includes("maestro")) {
+                await fs_extra_1.default.appendFile(ciPath, `
+  e2e:
+    name: E2E (Maestro)
+    runs-on: macos-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: npm
+      - run: npm install
+      - name: Install Maestro
+        run: curl -Ls "https://get.maestro.mobile.dev" | bash
+      - run: maestro test .maestro/flows/
+`);
+            }
+        }
+    }
+}
 async function configureEnv(targetPath, platform) {
     // Always create .env.example so devs know where to put secrets
     await writeIfMissing(path_1.default.join(targetPath, ".env.example"), `# Environment variables — copy to .env and fill in values

package/dist/src/generators/codeGenerator.js

@@ -0,0 +1,288 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCode = generateCode;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+// ---------------------------------------------------------------------------
+// Project context detection
+// ---------------------------------------------------------------------------
+async function detectProjectConfig() {
+    let dir = process.cwd();
+    const root = path_1.default.parse(dir).root;
+    while (dir !== root) {
+        const pkgPath = path_1.default.join(dir, "package.json");
+        if (await fs_extra_1.default.pathExists(pkgPath)) {
+            const pkg = await fs_extra_1.default.readJson(pkgPath);
+            if (pkg.rnstarterkitConfig) {
+                return { config: pkg.rnstarterkitConfig, projectRoot: dir };
+            }
+        }
+        dir = path_1.default.dirname(dir);
+    }
+    throw new Error("❌ No rnstarterkitConfig found in package.json.\n" +
+        "   Run this command from inside a project created with create-rnstarterkit.");
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function toPascalCase(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function toCamelCase(str) {
+    return str.charAt(0).toLowerCase() + str.slice(1);
+}
+async function writeAndLog(filePath, content) {
+    if (await fs_extra_1.default.pathExists(filePath)) {
+        console.error(`❌ File already exists: ${filePath}`);
+        process.exit(1);
+    }
+    await fs_extra_1.default.ensureDir(path_1.default.dirname(filePath));
+    await fs_extra_1.default.writeFile(filePath, content, "utf8");
+    console.log(`✅ Created ${path_1.default.relative(process.cwd(), filePath)}`);
+}
+// ---------------------------------------------------------------------------
+// screen generator
+// ---------------------------------------------------------------------------
+function screenStateImports(config) {
+    if (!config.auth)
+        return "";
+    if (config.state === "Redux Toolkit") {
+        return `import { useAppSelector } from '../store/hooks';\n`;
+    }
+    if (config.state === "Zustand") {
+        return `import { useAuthStore } from '../store/authStore';\n`;
+    }
+    if (config.state === "Context API") {
+        return `import { useContext } from 'react';\nimport { AuthContext } from '../context/AuthContext';\n`;
+    }
+    return "";
+}
+function screenStateHook(config) {
+    if (!config.auth)
+        return "";
+    if (config.state === "Redux Toolkit") {
+        return `\n  const token = useAppSelector((state) => state.auth.token);\n`;
+    }
+    if (config.state === "Zustand") {
+        return `\n  const { token } = useAuthStore();\n`;
+    }
+    if (config.state === "Context API") {
+        return `\n  const { token } = useContext(AuthContext);\n`;
+    }
+    return "";
+}
+async function generateScreen(name, config, projectRoot) {
+    const screenName = toPascalCase(name);
+    const fileName = `${screenName}Screen.tsx`;
+    const targetDir = config.platform === "Expo"
+        ? path_1.default.join(projectRoot, "app")
+        : path_1.default.join(projectRoot, "src", "screens");
+    const filePath = path_1.default.join(targetDir, fileName);
+    const stateImports = screenStateImports(config);
+    const stateHook = screenStateHook(config);
+    const layoutImport = config.platform === "React Native CLI"
+        ? `import ScreenLayout from '../components/layout/ScreenLayout';\n`
+        : "";
+    const wrapper = config.platform === "React Native CLI"
+        ? ["<ScreenLayout>", "    </ScreenLayout>"]
+        : ["<View style={styles.container}>", "    </View>"];
+    const content = config.platform === "Expo"
+        ? `import React from 'react';
+import { View, Text, StyleSheet } from 'react-native';
+${stateImports}
+export default function ${screenName}Screen() {${stateHook}
+  return (
+    ${wrapper[0]}
+      <Text style={styles.title}>${screenName}</Text>
+    ${wrapper[1]}
+  );
+}
+
+const styles = StyleSheet.create({
+  container: { flex: 1, alignItems: 'center', justifyContent: 'center', padding: 20 },
+  title: { fontSize: 24, fontWeight: 'bold', color: '#111827' },
+});
+`
+        : `import React from 'react';
+import { Text, StyleSheet } from 'react-native';
+${layoutImport}${stateImports}
+export default function ${screenName}Screen() {${stateHook}
+  return (
+    ${wrapper[0]}
+      <Text style={styles.title}>${screenName}</Text>
+    ${wrapper[1]}
+  );
+}
+
+const styles = StyleSheet.create({
+  title: { fontSize: 24, fontWeight: 'bold', color: '#111827' },
+});
+`;
+    await writeAndLog(filePath, content);
+}
+// ---------------------------------------------------------------------------
+// component generator
+// ---------------------------------------------------------------------------
+async function generateComponent(name, projectRoot) {
+    const componentName = toPascalCase(name);
+    const filePath = path_1.default.join(projectRoot, "src", "components", `${componentName}.tsx`);
+    const content = `import React from 'react';
+import { View, Text, StyleSheet, type ViewStyle } from 'react-native';
+
+type ${componentName}Props = {
+  label?: string;
+  style?: ViewStyle;
+};
+
+export function ${componentName}({ label = '${componentName}', style }: ${componentName}Props) {
+  return (
+    <View style={[styles.container, style]}>
+      <Text style={styles.label}>{label}</Text>
+    </View>
+  );
+}
+
+const styles = StyleSheet.create({
+  container: { padding: 12 },
+  label: { fontSize: 14, color: '#374151' },
+});
+`;
+    await writeAndLog(filePath, content);
+}
+// ---------------------------------------------------------------------------
+// hook generator
+// ---------------------------------------------------------------------------
+async function generateHook(name, projectRoot) {
+    const hookName = `use${toPascalCase(name)}`;
+    const filePath = path_1.default.join(projectRoot, "src", "hooks", `${hookName}.ts`);
+    const content = `import { useState, useCallback } from 'react';
+
+type ${toPascalCase(name)}State = {
+  data: null;
+  isLoading: boolean;
+  error: string | null;
+};
+
+export function ${hookName}() {
+  const [state, setState] = useState<${toPascalCase(name)}State>({
+    data: null,
+    isLoading: false,
+    error: null,
+  });
+
+  const execute = useCallback(async () => {
+    setState((prev) => ({ ...prev, isLoading: true, error: null }));
+    try {
+      // TODO: implement hook logic
+      setState((prev) => ({ ...prev, isLoading: false }));
+    } catch (err) {
+      setState((prev) => ({
+        ...prev,
+        isLoading: false,
+        error: err instanceof Error ? err.message : 'Unknown error',
+      }));
+    }
+  }, []);
+
+  return { ...state, execute };
+}
+`;
+    await writeAndLog(filePath, content);
+}
+// ---------------------------------------------------------------------------
+// slice generator
+// ---------------------------------------------------------------------------
+async function generateSlice(name, config, projectRoot) {
+    if (config.state !== "Redux Toolkit") {
+        console.error(`❌ Slice generation requires Redux Toolkit. This project uses: ${config.state || "None"}`);
+        process.exit(1);
+    }
+    const sliceName = toCamelCase(name);
+    const SliceName = toPascalCase(name);
+    const filePath = path_1.default.join(projectRoot, "src", "store", `${sliceName}Slice.ts`);
+    // --- write the slice file ---
+    const sliceContent = `import { createSlice, type PayloadAction } from '@reduxjs/toolkit';
+
+interface ${SliceName}State {
+  // TODO: define your state shape
+  data: null;
+  isLoading: boolean;
+  error: string | null;
+}
+
+const initialState: ${SliceName}State = {
+  data: null,
+  isLoading: false,
+  error: null,
+};
+
+const ${sliceName}Slice = createSlice({
+  name: '${sliceName}',
+  initialState,
+  reducers: {
+    setLoading(state, _action: PayloadAction<boolean>) {
+      state.isLoading = _action.payload;
+    },
+    setError(state, action: PayloadAction<string | null>) {
+      state.error = action.payload;
+    },
+    reset() {
+      return initialState;
+    },
+  },
+});
+
+export const { setLoading, setError, reset } = ${sliceName}Slice.actions;
+export default ${sliceName}Slice.reducer;
+`;
+    await writeAndLog(filePath, sliceContent);
+    // --- patch store.ts to register the new reducer ---
+    const storePath = path_1.default.join(projectRoot, "src", "store", "store.ts");
+    if (await fs_extra_1.default.pathExists(storePath)) {
+        let storeContent = await fs_extra_1.default.readFile(storePath, "utf8");
+        const importLine = `import ${sliceName}Reducer from './${sliceName}Slice';\n`;
+        if (!storeContent.includes(importLine)) {
+            // Add import after last existing import
+            storeContent = storeContent.replace(/^(import .+\n)+/m, (match) => `${match}${importLine}`);
+        }
+        // Add reducer key inside configureStore reducer object
+        if (!storeContent.includes(`${sliceName}:`)) {
+            storeContent = storeContent.replace(/reducer:\s*\{/, `reducer: {\n    ${sliceName}: ${sliceName}Reducer,`);
+        }
+        await fs_extra_1.default.writeFile(storePath, storeContent, "utf8");
+        console.log(`🔗 Registered ${sliceName} in src/store/store.ts`);
+    }
+    else {
+        console.warn(`⚠️  src/store/store.ts not found — add the reducer manually:\n` +
+            `   import ${sliceName}Reducer from './${sliceName}Slice';\n` +
+            `   // add ${sliceName}: ${sliceName}Reducer to your store`);
+    }
+}
+// ---------------------------------------------------------------------------
+// Public entry point
+// ---------------------------------------------------------------------------
+async function generateCode(type, name) {
+    const { config, projectRoot } = await detectProjectConfig();
+    const validTypes = ["screen", "component", "hook", "slice"];
+    if (!validTypes.includes(type)) {
+        console.error(`❌ Unknown type "${type}". Valid types: ${validTypes.join(" | ")}`);
+        process.exit(1);
+    }
+    switch (type) {
+        case "screen":
+            await generateScreen(name, config, projectRoot);
+            break;
+        case "component":
+            await generateComponent(name, projectRoot);
+            break;
+        case "hook":
+            await generateHook(name, projectRoot);
+            break;
+        case "slice":
+            await generateSlice(name, config, projectRoot);
+            break;
+    }
+}

package/dist/templates/optional/i18n/src/i18n/hooks/useAppTranslation.ts

@@ -0,0 +1,28 @@
+import { useTranslation } from 'react-i18next';
+import type en from '../locales/en.json';
+
+// Derive the full key union from the English locale so translations are type-safe
+type TranslationKeys = typeof en;
+type DotPrefix<T extends string, K extends string> = `${T}.${K}`;
+
+type LeafKeys<T, Prefix extends string = ''> = {
+  [K in keyof T]: T[K] extends object
+    ? LeafKeys<T[K], Prefix extends '' ? Extract<K, string> : DotPrefix<Prefix, Extract<K, string>>>
+    : Prefix extends ''
+    ? Extract<K, string>
+    : DotPrefix<Prefix, Extract<K, string>>;
+}[keyof T];
+
+export type AppTranslationKey = LeafKeys<TranslationKeys>;
+
+/**
+ * Typed wrapper around react-i18next's useTranslation.
+ * Keys are inferred from en.json so you get autocompletion + compile-time safety.
+ *
+ * @example
+ *   const { t } = useAppTranslation();
+ *   <Text>{t('auth.signIn')}</Text>
+ */
+export function useAppTranslation() {
+  return useTranslation();
+}

package/dist/templates/optional/i18n/src/i18n/i18n.ts

@@ -0,0 +1,30 @@
+import i18n from 'i18next';
+import { initReactI18next } from 'react-i18next';
+import * as RNLocalize from 'react-native-localize';
+
+import en from './locales/en.json';
+import es from './locales/es.json';
+
+const resources = {
+  en: { translation: en },
+  es: { translation: es },
+};
+
+const fallbackLocale = 'en';
+const deviceLocales = RNLocalize.getLocales();
+const bestMatch = deviceLocales[0]?.languageCode ?? fallbackLocale;
+
+void i18n
+  .use(initReactI18next)
+  .init({
+    resources,
+    lng: bestMatch,
+    fallbackLng: fallbackLocale,
+    interpolation: {
+      // React already escapes values
+      escapeValue: false,
+    },
+    compatibilityJSON: 'v4',
+  });
+
+export default i18n;

package/dist/templates/optional/i18n/src/i18n/locales/en.json

@@ -0,0 +1,32 @@
+{
+  "welcome": {
+    "title": "Welcome",
+    "subtitle": "Get started with your app",
+    "getStarted": "Get Started"
+  },
+  "auth": {
+    "signIn": "Sign In",
+    "signUp": "Sign Up",
+    "signOut": "Sign Out",
+    "email": "Email",
+    "password": "Password",
+    "confirmPassword": "Confirm Password",
+    "forgotPassword": "Forgot password?",
+    "noAccount": "Don't have an account?",
+    "haveAccount": "Already have an account?"
+  },
+  "common": {
+    "loading": "Loading...",
+    "error": "Something went wrong",
+    "retry": "Try again",
+    "cancel": "Cancel",
+    "save": "Save",
+    "delete": "Delete",
+    "confirm": "Confirm"
+  },
+  "screens": {
+    "home": "Home",
+    "profile": "Profile",
+    "settings": "Settings"
+  }
+}

package/dist/templates/optional/i18n/src/i18n/locales/es.json

@@ -0,0 +1,32 @@
+{
+  "welcome": {
+    "title": "Bienvenido",
+    "subtitle": "Empieza con tu aplicación",
+    "getStarted": "Comenzar"
+  },
+  "auth": {
+    "signIn": "Iniciar sesión",
+    "signUp": "Registrarse",
+    "signOut": "Cerrar sesión",
+    "email": "Correo electrónico",
+    "password": "Contraseña",
+    "confirmPassword": "Confirmar contraseña",
+    "forgotPassword": "¿Olvidaste tu contraseña?",
+    "noAccount": "¿No tienes cuenta?",
+    "haveAccount": "¿Ya tienes cuenta?"
+  },
+  "common": {
+    "loading": "Cargando...",
+    "error": "Algo salió mal",
+    "retry": "Intentar de nuevo",
+    "cancel": "Cancelar",
+    "save": "Guardar",
+    "delete": "Eliminar",
+    "confirm": "Confirmar"
+  },
+  "screens": {
+    "home": "Inicio",
+    "profile": "Perfil",
+    "settings": "Configuración"
+  }
+}

package/dist/templates/optional/maestro/.maestro/flows/01_welcome.yaml

@@ -0,0 +1,5 @@
+appId: com.rnstarterkit.app
+---
+- launchApp
+- assertVisible: "Get Started"
+- tapOn: "Get Started"

package/dist/templates/optional/maestro-auth/.maestro/flows/01_welcome.yaml

@@ -0,0 +1,5 @@
+appId: com.rnstarterkit.app
+---
+- launchApp
+- assertVisible: "Get Started"
+- tapOn: "Get Started"

package/dist/templates/optional/maestro-auth/.maestro/flows/02_login.yaml

@@ -0,0 +1,13 @@
+appId: com.rnstarterkit.app
+---
+- launchApp
+- tapOn: "Get Started"
+- tapOn: "Sign In"
+- tapOn:
+    id: "email-input"
+- inputText: "test@example.com"
+- tapOn:
+    id: "password-input"
+- inputText: "password123"
+- tapOn: "Sign In"
+- assertVisible: "Home"