react-native-architecture-generator 1.1.0

package/dist/lib/utils/feature-helper.js

@@ -0,0 +1,400 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { Architecture, StateManagement, Routing } from '../models/config.js';
+import { StringUtils } from './string-utils.js';
+/**
+ * Generates feature modules in 4 different architecture patterns:
+ *   1. Clean Architecture (Domain → Data → Presentation)
+ *   2. Feature-Based (Lightweight, flat structure)
+ *   3. Atomic Design + Feature (Atoms → Molecules → Organisms)
+ *   4. MVVM with Hooks (Model → ViewModel → View)
+ */
+export class FeatureHelper {
+    static async generateFeature(name, config) {
+        switch (config.architecture) {
+            case Architecture.cleanArchitecture:
+                await this.generateCleanArchFeature(name, config);
+                break;
+            case Architecture.featureBased:
+                await this.generateFeatureBasedFeature(name, config);
+                break;
+            case Architecture.atomicDesign:
+                await this.generateAtomicDesignFeature(name, config);
+                break;
+            case Architecture.mvvm:
+                await this.generateMvvmFeature(name, config);
+                break;
+        }
+    }
+    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+    //  1. CLEAN ARCHITECTURE
+    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+    static async generateCleanArchFeature(name, config) {
+        const root = process.cwd();
+        const snakeName = StringUtils.toSnakeCase(name);
+        const pascalName = StringUtils.toPascalCase(name);
+        const featurePath = path.join(root, 'src', 'features', snakeName);
+        // Directories
+        const layers = [
+            'data/datasources',
+            'data/models',
+            'data/repositories',
+            'domain/entities',
+            'domain/repositories',
+            'domain/usecases',
+            'presentation/screens',
+            'presentation/components',
+            'presentation/hooks',
+            `presentation/${config.stateManagement}`,
+        ];
+        for (const layer of layers) {
+            await fs.ensureDir(path.join(featurePath, layer));
+        }
+        // Entity
+        await this.writeFile(path.join(featurePath, 'domain', 'entities', `${snakeName}Entity.ts`), `export interface ${pascalName}Entity {\n  id: number;\n}\n`);
+        // Repository interface
+        await this.writeFile(path.join(featurePath, 'domain', 'repositories', `${pascalName}Repository.ts`), `import type { ${pascalName}Entity } from '../entities/${snakeName}Entity';\n\nexport interface I${pascalName}Repository {\n  get${pascalName}Data(): Promise<${pascalName}Entity>;\n}\n`);
+        // Use Case
+        await this.writeFile(path.join(featurePath, 'domain', 'usecases', `Get${pascalName}UseCase.ts`), `import type { I${pascalName}Repository } from '../repositories/${pascalName}Repository';
+import type { ${pascalName}Entity } from '../entities/${snakeName}Entity';
+
+export class Get${pascalName}UseCase {
+  constructor(private repository: I${pascalName}Repository) {}
+
+  async execute(): Promise<${pascalName}Entity> {
+    return this.repository.get${pascalName}Data();
+  }
+}
+`);
+        // Model
+        await this.writeFile(path.join(featurePath, 'data', 'models', `${pascalName}Model.ts`), `import type { ${pascalName}Entity } from '../../domain/entities/${snakeName}Entity';
+
+export class ${pascalName}Model implements ${pascalName}Entity {
+  id: number;
+
+  constructor(data: { id: number }) {
+    this.id = data.id;
+  }
+
+  static fromJson(json: Record<string, unknown>): ${pascalName}Model {
+    return new ${pascalName}Model({ id: json['id'] as number });
+  }
+
+  toJson(): Record<string, unknown> {
+    return { id: this.id };
+  }
+}
+`);
+        // Data Source
+        await this.writeFile(path.join(featurePath, 'data', 'datasources', `${pascalName}RemoteDataSource.ts`), `import apiClient from '../../../core/api/apiClient';
+import { ${pascalName}Model } from '../models/${pascalName}Model';
+
+export interface I${pascalName}RemoteDataSource {
+  get${pascalName}FromApi(): Promise<${pascalName}Model>;
+}
+
+export class ${pascalName}RemoteDataSourceImpl implements I${pascalName}RemoteDataSource {
+  async get${pascalName}FromApi(): Promise<${pascalName}Model> {
+    const response = await apiClient.get('/${snakeName}');
+    return ${pascalName}Model.fromJson(response.data);
+  }
+}
+`);
+        // Repository Impl
+        await this.writeFile(path.join(featurePath, 'data', 'repositories', `${pascalName}RepositoryImpl.ts`), `import type { I${pascalName}Repository } from '../../domain/repositories/${pascalName}Repository';
+import type { ${pascalName}Entity } from '../../domain/entities/${snakeName}Entity';
+import type { I${pascalName}RemoteDataSource } from '../datasources/${pascalName}RemoteDataSource';
+import { ServerFailure } from '../../../core/errors/failures';
+
+export class ${pascalName}RepositoryImpl implements I${pascalName}Repository {
+  constructor(private remoteDataSource: I${pascalName}RemoteDataSource) {}
+
+  async get${pascalName}Data(): Promise<${pascalName}Entity> {
+    try {
+      return await this.remoteDataSource.get${pascalName}FromApi();
+    } catch (error) {
+      throw new ServerFailure(String(error));
+    }
+  }
+}
+`);
+        // State Management
+        await this.generateStateManagement(featurePath, name, config, 'presentation');
+        // Screens
+        if (name === 'auth') {
+            await this.generateAuthScreens(featurePath, config, 'presentation/screens');
+        }
+        else {
+            await this.generateDefaultScreen(featurePath, name, 'presentation/screens');
+        }
+        // Navigation Registration
+        await this.registerInNavigation(name, config);
+        // Tests
+        if (config.tests) {
+            await this.generateCleanArchTest(name, config);
+        }
+    }
+    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+    //  2. FEATURE-BASED (LIGHTWEIGHT)
+    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+    static async generateFeatureBasedFeature(name, config) {
+        const root = process.cwd();
+        const snakeName = StringUtils.toSnakeCase(name);
+        const pascalName = StringUtils.toPascalCase(name);
+        const camelName = StringUtils.toCamelCase(name);
+        const featurePath = path.join(root, 'src', 'features', snakeName);
+        const dirs = [
+            'components',
+            'hooks',
+            'screens',
+            'services',
+            'types',
+            'utils',
+        ];
+        for (const dir of dirs) {
+            await fs.ensureDir(path.join(featurePath, dir));
+        }
+        // Types
+        await this.writeFile(path.join(featurePath, 'types', `${camelName}.types.ts`), `export interface ${pascalName} {\n  id: number;\n}\n`);
+        // Service
+        await this.writeFile(path.join(featurePath, 'services', `${camelName}.service.ts`), `import apiClient from '../../core/api/apiClient';
+import type { ${pascalName} } from '../types/${camelName}.types';
+
+export const ${camelName}Service = {
+  async getAll(): Promise<${pascalName}[]> {
+    const response = await apiClient.get('/${snakeName}');
+    return response.data;
+  },
+};
+`);
+        // Hook
+        await this.writeFile(path.join(featurePath, 'hooks', `use${pascalName}.ts`), `import { useState, useCallback } from 'react';
+import type { ${pascalName} } from '../types/${camelName}.types';
+import { ${camelName}Service } from '../services/${camelName}.service';
+
+export const use${pascalName} = () => {
+  const [data, setData] = useState<${pascalName} | null>(null);
+  const [isLoading, setIsLoading] = useState(false);
+
+  const fetch = useCallback(async () => {
+    setIsLoading(true);
+    try {
+      const result = await ${camelName}Service.getAll();
+      setData(result[0]);
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+
+  return { data, isLoading, fetch };
+};
+`);
+        // Screens
+        if (name === 'auth') {
+            await this.generateAuthScreens(featurePath, config, 'screens');
+        }
+        else {
+            await this.generateDefaultScreen(featurePath, name, 'screens');
+        }
+        await this.registerInNavigation(name, config);
+        if (config.tests) {
+            await this.generateFeatureBasedTest(name, config);
+        }
+    }
+    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+    //  3. ATOMIC DESIGN + FEATURE
+    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+    static async generateAtomicDesignFeature(name, config) {
+        const root = process.cwd();
+        const snakeName = StringUtils.toSnakeCase(name);
+        const pascalName = StringUtils.toPascalCase(name);
+        const camelName = StringUtils.toCamelCase(name);
+        const featurePath = path.join(root, 'src', 'features', snakeName);
+        const dirs = ['atoms', 'molecules', 'organisms', 'templates', 'screens', 'hooks', 'services', 'types'];
+        for (const dir of dirs) {
+            await fs.ensureDir(path.join(featurePath, dir));
+        }
+        // Atom: Button (Theme-aware)
+        await this.writeFile(path.join(featurePath, 'atoms', `${pascalName}Button.tsx`), `import React from 'react';
+import { TouchableOpacity, Text, StyleSheet } from 'react-native';
+import { useTheme } from '../../../core/theme/ThemeContext';
+
+interface Props { title: string; onPress: () => void; }
+
+export const ${pascalName}Button: React.FC<Props> = ({ title, onPress }) => {
+  const { colors } = useTheme();
+  return (
+    <TouchableOpacity style={[styles.btn, { backgroundColor: colors.primary }]} onPress={onPress}>
+      <Text style={styles.text}>{title}</Text>
+    </TouchableOpacity>
+  );
+};
+
+const styles = StyleSheet.create({
+  btn: { padding: 16, borderRadius: 12, alignItems: 'center' },
+  text: { color: '#fff', fontSize: 16, fontWeight: 'bold' },
+});
+`);
+        // Molecule: FormField
+        await this.writeFile(path.join(featurePath, 'molecules', `${pascalName}FormField.tsx`), `import React from 'react';
+import { View, Text, TextInput, StyleSheet } from 'react-native';
+import { useTheme } from '../../../core/theme/ThemeContext';
+
+interface Props { label: string; value: string; onChangeText: (t: string) => void; }
+
+export const ${pascalName}FormField: React.FC<Props> = ({ label, value, onChangeText }) => {
+  const { colors } = useTheme();
+  return (
+    <View style={styles.container}>
+      <Text style={[styles.label, { color: colors.textPrimary }]}>{label}</Text>
+      <TextInput style={[styles.input, { borderColor: colors.divider }]} value={value} onChangeText={onChangeText} />
+    </View>
+  );
+};
+
+const styles = StyleSheet.create({
+  container: { marginBottom: 16 },
+  label: { fontSize: 14, marginBottom: 8 },
+  input: { borderWidth: 1, borderRadius: 8, padding: 12 },
+});
+`);
+        // Screens
+        if (name === 'auth') {
+            await this.generateAuthScreens(featurePath, config, 'screens');
+        }
+        else {
+            await this.generateDefaultScreen(featurePath, name, 'screens');
+        }
+        await this.registerInNavigation(name, config);
+        if (config.tests)
+            await this.generateAtomicDesignTest(name, config);
+    }
+    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+    //  4. MVVM WITH HOOKS
+    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+    static async generateMvvmFeature(name, config) {
+        const root = process.cwd();
+        const snakeName = StringUtils.toSnakeCase(name);
+        const pascalName = StringUtils.toPascalCase(name);
+        const camelName = StringUtils.toCamelCase(name);
+        const featurePath = path.join(root, 'src', 'features', snakeName);
+        const dirs = ['models', 'viewmodels', 'views/screens', 'views/components', 'services'];
+        for (const dir of dirs) {
+            await fs.ensureDir(path.join(featurePath, dir));
+        }
+        // ViewModel
+        await this.writeFile(path.join(featurePath, 'viewmodels', `use${pascalName}ViewModel.ts`), `import { useState, useCallback } from 'react';
+
+export const use${pascalName}ViewModel = () => {
+  const [isLoading, setIsLoading] = useState(false);
+  const fetchData = useCallback(() => { /* ... */ }, []);
+  return { isLoading, fetchData };
+};
+`);
+        // Screen
+        if (name === 'auth') {
+            await this.generateAuthScreens(featurePath, config, 'views/screens');
+        }
+        else {
+            await this.generateDefaultScreen(featurePath, name, 'views/screens');
+        }
+        await this.registerInNavigation(name, config, 'views/screens');
+        if (config.tests)
+            await this.generateMvvmTest(name, config);
+    }
+    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+    //  SHARED: State Management
+    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+    static async generateStateManagement(featurePath, name, config, baseFolder) {
+        const pascalName = StringUtils.toPascalCase(name);
+        const camelName = StringUtils.toCamelCase(name);
+        const smPath = path.join(featurePath, baseFolder, config.stateManagement);
+        switch (config.stateManagement) {
+            case StateManagement.redux:
+                await this.writeFile(path.join(smPath, `${camelName}Slice.ts`), `import { createSlice, type PayloadAction } from '@reduxjs/toolkit';
+
+export const ${camelName}Slice = createSlice({
+  name: '${camelName}',
+  initialState: { data: null, isLoading: false },
+  reducers: {
+    setData: (state, action: PayloadAction<any>) => { state.data = action.payload; },
+  },
+});
+
+export const { setData } = ${camelName}Slice.actions;
+export default ${camelName}Slice.reducer;
+`);
+                break;
+            case StateManagement.zustand:
+                await this.writeFile(path.join(smPath, `use${pascalName}Store.ts`), `import { create } from 'zustand';
+
+export const use${pascalName}Store = create<any>((set) => ({
+  data: null,
+  setData: (data: any) => set({ data }),
+}));
+`);
+                break;
+        }
+    }
+    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+    //  SHARED: Auth Screens (Theme Integrated)
+    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+    static async generateAuthScreens(featurePath, config, screenFolder) {
+        const loginContent = `import React, { useState } from 'react';
+import { View, Text, TextInput, TouchableOpacity, StyleSheet, KeyboardAvoidingView, Platform } from 'react-native';
+import { useTheme } from '../../../core/theme/ThemeContext';
+
+export const LoginScreen: React.FC = () => {
+  const { colors } = useTheme();
+  return (
+    <KeyboardAvoidingView style={[styles.container, { backgroundColor: colors.background }]} behavior={Platform.OS === 'ios' ? 'padding' : undefined}>
+      <Text style={[styles.title, { color: colors.textPrimary }]}>Welcome</Text>
+      <TextInput style={[styles.input, { borderColor: colors.divider, color: colors.textPrimary }]} placeholder="Email" placeholderTextColor={colors.textSecondary} />
+      <TouchableOpacity style={[styles.btn, { backgroundColor: colors.primary }]}>
+        <Text style={styles.btnText}>Login</Text>
+      </TouchableOpacity>
+    </KeyboardAvoidingView>
+  );
+};
+
+const styles = StyleSheet.create({
+  container: { flex: 1, padding: 24, justifyContent: 'center' },
+  title: { fontSize: 32, fontWeight: 'bold', marginBottom: 24 },
+  input: { borderWidth: 1, borderRadius: 12, padding: 16, marginBottom: 16 },
+  btn: { padding: 18, borderRadius: 12, alignItems: 'center' },
+  btnText: { color: '#fff', fontSize: 18, fontWeight: 'bold' },
+});
+`;
+        await this.writeFile(path.join(featurePath, screenFolder, 'LoginScreen.tsx'), loginContent);
+        await this.writeFile(path.join(featurePath, screenFolder, 'RegisterScreen.tsx'), loginContent.replace('Login', 'Register'));
+    }
+    static async generateDefaultScreen(featurePath, name, screenFolder) {
+        const pascalName = StringUtils.toPascalCase(name);
+        await this.writeFile(path.join(featurePath, screenFolder, `${pascalName}Screen.tsx`), `import React from 'react';\nimport { View, Text } from 'react-native';\n\nexport const ${pascalName}Screen = () => <View><Text>${pascalName} Screen</Text></View>;\n`);
+    }
+    static async registerInNavigation(name, config, screenSubPath) {
+        if (config.routing === Routing.expoRouter)
+            return;
+        const navFile = path.join(process.cwd(), 'src', 'navigation', 'AppNavigator.tsx');
+        if (!(await fs.pathExists(navFile)))
+            return;
+        const pascalName = StringUtils.toPascalCase(name);
+        const snakeName = StringUtils.toSnakeCase(name);
+        const screenDir = screenSubPath || (config.architecture === Architecture.cleanArchitecture ? 'presentation/screens' : config.architecture === Architecture.mvvm ? 'views/screens' : 'screens');
+        let contents = await fs.readFile(navFile, 'utf-8');
+        const importStr = name === 'auth'
+            ? `import { LoginScreen } from '../features/auth/${screenDir}/LoginScreen';\nimport { RegisterScreen } from '../features/auth/${screenDir}/RegisterScreen';`
+            : `import { ${pascalName}Screen } from '../features/${snakeName}/${screenDir}/${pascalName}Screen';`;
+        if (!contents.includes(importStr.split('\n')[0]))
+            contents = `${importStr}\n${contents}`;
+        await fs.writeFile(navFile, contents);
+    }
+    static async generateCleanArchTest(name, _config) { }
+    static async generateFeatureBasedTest(name, _config) { }
+    static async generateAtomicDesignTest(name, _config) { }
+    static async generateMvvmTest(name, _config) { }
+    static async writeFile(filePath, content) {
+        await fs.ensureDir(path.dirname(filePath));
+        await fs.writeFile(filePath, content);
+    }
+}

package/dist/lib/utils/file-helper.d.ts

@@ -0,0 +1,4 @@
+import type { GeneratorConfig } from '../models/config.js';
+export declare class FileHelper {
+    static generateBaseStructure(config: GeneratorConfig): Promise<void>;
+}

package/dist/lib/utils/file-helper.js

@@ -0,0 +1,62 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { ConfigHelper } from './config-helper.js';
+import { BaseTemplates } from '../templates/base-templates.js';
+import { PackageJsonHelper } from './packagejson-helper.js';
+export class FileHelper {
+    static async generateBaseStructure(config) {
+        const root = process.cwd();
+        // 1. Create Directories
+        const dirs = [
+            'src/core/api',
+            'src/core/errors',
+            'src/core/theme',
+            'src/core/utils',
+            'src/core/components',
+            'src/features',
+            'src/navigation',
+            'src/state',
+            'assets/images',
+            'assets/fonts',
+        ];
+        if (config.localization) {
+            dirs.push('src/i18n/locales');
+        }
+        if (config.tests) {
+            dirs.push('__tests__/unit', '__tests__/integration');
+        }
+        for (const dir of dirs) {
+            await fs.ensureDir(path.join(root, dir));
+        }
+        // 2. Create Base Files
+        const files = {
+            'src/App.tsx': BaseTemplates.appEntryContent(config),
+            'src/core/api/apiClient.ts': BaseTemplates.apiClientContent(),
+            'src/core/errors/failures.ts': BaseTemplates.failuresContent(),
+            'src/core/theme/AppTheme.ts': BaseTemplates.themeContent(),
+            'src/core/theme/ThemeContext.tsx': BaseTemplates.themeContextContent(),
+            'src/core/constants/AppConstants.ts': BaseTemplates.constantsContent(),
+            'src/navigation/AppNavigator.tsx': BaseTemplates.navigationContent(config),
+            'src/state/store.ts': BaseTemplates.storeContent(config),
+            '.env.development': 'API_BASE_URL=https://dev.api.example.com\n',
+            '.env.production': 'API_BASE_URL=https://api.example.com\n',
+            '.gitignore': BaseTemplates.gitignoreContent(),
+        };
+        if (config.localization) {
+            files['src/i18n/i18n.ts'] = BaseTemplates.i18nConfigContent();
+            files['src/i18n/locales/en.json'] = BaseTemplates.localeEnContent();
+        }
+        if (config.tests) {
+            files['__tests__/unit/sample.test.ts'] = BaseTemplates.sampleTestContent();
+        }
+        for (const [filePath, content] of Object.entries(files)) {
+            const fullPath = path.join(root, filePath);
+            await fs.ensureDir(path.dirname(fullPath));
+            await fs.writeFile(fullPath, content);
+        }
+        // 3. Update package.json with dependencies
+        await PackageJsonHelper.addDependencies(config);
+        // 4. Save config
+        await ConfigHelper.saveConfig(config);
+    }
+}

package/dist/lib/utils/packagejson-helper.d.ts

@@ -0,0 +1,4 @@
+import type { GeneratorConfig } from '../models/config.js';
+export declare class PackageJsonHelper {
+    static addDependencies(config: GeneratorConfig): Promise<void>;
+}

package/dist/lib/utils/packagejson-helper.js

@@ -0,0 +1,76 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { StateManagement, Routing } from '../models/config.js';
+export class PackageJsonHelper {
+    static async addDependencies(config) {
+        const pkgPath = path.join(process.cwd(), 'package.json');
+        if (!(await fs.pathExists(pkgPath)))
+            return;
+        const pkg = await fs.readJson(pkgPath);
+        if (!pkg.dependencies)
+            pkg.dependencies = {};
+        if (!pkg.devDependencies)
+            pkg.devDependencies = {};
+        // ── Common Dependencies ──
+        const deps = {
+            'axios': '^1.13.5',
+            'react-native-config': '^1.6.1',
+        };
+        // ── State Management ──
+        switch (config.stateManagement) {
+            case StateManagement.redux:
+                deps['@reduxjs/toolkit'] = '^2.11.2';
+                deps['react-redux'] = '^9.2.0';
+                break;
+            case StateManagement.zustand:
+                deps['zustand'] = '^5.0.11';
+                break;
+            case StateManagement.context:
+                // React Context is built-in, no dep needed
+                break;
+        }
+        // ── Routing ──
+        switch (config.routing) {
+            case Routing.reactNavigation:
+                deps['@react-navigation/native'] = '^7.1.28';
+                deps['@react-navigation/native-stack'] = '^7.13.0';
+                deps['react-native-screens'] = '^4.23.0';
+                deps['react-native-safe-area-context'] = '^5.6.2';
+                break;
+            case Routing.expoRouter:
+                deps['expo-router'] = '^6.0.23';
+                break;
+        }
+        // ── Firebase ──
+        if (config.firebase) {
+            deps['@react-native-firebase/app'] = '^23.8.6';
+        }
+        // ── Localization ──
+        if (config.localization) {
+            deps['i18next'] = '^25.8.13';
+            deps['react-i18next'] = '^16.5.4';
+        }
+        // ── Dev Dependencies ──
+        const devDeps = {
+            '@types/react': '^19.2.14',
+            'typescript': '^5.9.3',
+        };
+        if (config.tests) {
+            devDeps['jest'] = '^30.2.0';
+            devDeps['@testing-library/react-native'] = '^13.3.3';
+        }
+        // react-redux v9+ has built-in types, no need for @types/react-redux
+        // Merge without overwriting existing
+        for (const [name, version] of Object.entries(deps)) {
+            if (!pkg.dependencies[name]) {
+                pkg.dependencies[name] = version;
+            }
+        }
+        for (const [name, version] of Object.entries(devDeps)) {
+            if (!pkg.devDependencies[name]) {
+                pkg.devDependencies[name] = version;
+            }
+        }
+        await fs.writeJson(pkgPath, pkg, { spaces: 2 });
+    }
+}

package/dist/lib/utils/string-utils.d.ts

@@ -0,0 +1,9 @@
+/**
+ * String utility functions for naming convention conversions.
+ */
+export declare class StringUtils {
+    static toSnakeCase(name: string): string;
+    static toPascalCase(name: string): string;
+    static toCamelCase(name: string): string;
+    static toKebabCase(name: string): string;
+}

package/dist/lib/utils/string-utils.js

@@ -0,0 +1,28 @@
+/**
+ * String utility functions for naming convention conversions.
+ */
+export class StringUtils {
+    static toSnakeCase(name) {
+        return name
+            .replace(/([A-Z])/g, '_$1')
+            .toLowerCase()
+            .replace(/^_/, '')
+            .replace(/_+/g, '_');
+    }
+    static toPascalCase(name) {
+        const snake = StringUtils.toSnakeCase(name);
+        return snake
+            .split('_')
+            .map((s) => (s.length === 0 ? '' : s[0].toUpperCase() + s.slice(1)))
+            .join('');
+    }
+    static toCamelCase(name) {
+        const pascal = StringUtils.toPascalCase(name);
+        if (pascal.length === 0)
+            return '';
+        return pascal[0].toLowerCase() + pascal.slice(1);
+    }
+    static toKebabCase(name) {
+        return StringUtils.toSnakeCase(name).replace(/_/g, '-');
+    }
+}

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "react-native-architecture-generator",
+  "version": "1.1.0",
+  "description": "A professional CLI tool to scaffold React Native apps with Clean Architecture, MVVM, Atomic Design, or Feature-Based patterns.",
+  "type": "module",
+  "main": "./dist/lib/index.js",
+  "module": "./dist/lib/index.js",
+  "types": "./dist/lib/index.d.ts",
+  "bin": {
+    "rn-arch-gen": "./dist/bin/rn_arch_gen.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/lib/index.d.ts",
+      "import": "./dist/lib/index.js"
+    }
+  },
+  "files": [
+    "dist/",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "start": "node ./dist/bin/rn_arch_gen.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "react-native",
+    "clean-architecture",
+    "feature-based",
+    "atomic-design",
+    "mvvm",
+    "cli",
+    "scaffolding",
+    "generator",
+    "code-generation",
+    "boilerplate",
+    "typescript",
+    "redux",
+    "zustand"
+  ],
+  "author": "Naimish Kumar <vnaimishkumar@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Naimish-Kumar/react_native_architecture_generator.git"
+  },
+  "homepage": "https://github.com/Naimish-Kumar/react_native_architecture_generator#readme",
+  "bugs": {
+    "url": "https://github.com/Naimish-Kumar/react_native_architecture_generator/issues"
+  },
+  "sideEffects": false,
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "commander": "^14.0.3",
+    "fs-extra": "^11.3.3",
+    "inquirer": "^13.1.0",
+    "ora": "^9.3.0"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/inquirer": "^9.0.9",
+    "@types/node": "^22.0.0",
+    "typescript": "^5.9.3"
+  }
+}