@ronas-it/nx-generators 0.10.1 → 0.10.3

package/src/generators/form/utils/get-form-utils-directory.ts

@@ -0,0 +1,46 @@
+import {
+  constants,
+  dynamicImport,
+  filterSource,
+  getNxLibsPaths,
+  LibraryType,
+  searchAliasPath,
+  searchNxLibsPaths,
+  selectProject
+} from '../../../shared/utils';
+import { runFormUtilsGenerator } from '../../../shared/generators';
+import { Tree } from '@nx/devkit';
+import { getAppName } from './get-app-name';
+
+function getFormUtilsPaths(): Array<string> {
+  const utilsLibsPaths = getNxLibsPaths([LibraryType.UTILS]);
+  return searchNxLibsPaths(utilsLibsPaths, 'utils/form/src', 'endsWith');
+}
+
+export async function getFormUtilsDirectory(tree: Tree, appName: string): Promise<string> {
+  const { default: autocomplete } = await dynamicImport<typeof import('inquirer-autocomplete-standalone')>('inquirer-autocomplete-standalone');
+
+  const formUtilsLibsPaths = getFormUtilsPaths();
+
+  if (!formUtilsLibsPaths.length) {
+    const formUtilsAppDirectory = (await selectProject(tree, 'application', 'It\'s necessary to generate form utilities. What application should they be in?')).name;
+    await runFormUtilsGenerator(tree, { directory: formUtilsAppDirectory });
+
+    return searchAliasPath(getFormUtilsPaths()[0]) as string;
+  }
+
+  if (formUtilsLibsPaths.length > 1) {
+    if (appName === constants.sharedValue) {
+      const path = formUtilsLibsPaths.find((path) => getAppName(path) === constants.sharedValue) as string;
+
+      return searchAliasPath(path) as string;
+    }
+
+    formUtilsLibsPaths[0] = await autocomplete({
+      message: 'Select the path of the library with the form utilities: ',
+      source: (input) => filterSource(input as string, formUtilsLibsPaths.filter((path) => [appName, constants.sharedValue].includes(getAppName(path))))
+    });
+  }
+
+  return searchAliasPath(formUtilsLibsPaths[0]) as string;
+}

package/src/generators/form/utils/update-index.ts

@@ -0,0 +1,14 @@
+import { Tree } from '@nx/devkit';
+import { kebabCase } from 'lodash';
+import { existsSync } from 'fs';
+import { appendFileContent } from '../../../shared/utils';
+
+export function updateIndex(formsPath: string, fileName: string, tree: Tree): void {
+  const formsIndexFilePath = `${formsPath}/index.ts`;
+  const newIndexContent = `export * from './${kebabCase(fileName)}';\n`;
+  if (!existsSync(formsIndexFilePath)) {
+    tree.write(formsIndexFilePath, newIndexContent);
+  } else {
+    appendFileContent(formsIndexFilePath, newIndexContent, tree);
+  }
+}

package/src/generators/lib-move/generator.ts

@@ -0,0 +1,57 @@
+import { execSync } from 'child_process';
+import * as path from 'path';
+import { Tree } from '@nx/devkit';
+import {
+  LibraryType,
+  askQuestion,
+  constants,
+  dynamicImport,
+  filterSource,
+  getLibraryDetailsByName,
+  selectProject,
+  validateLibraryType,
+  getLibDirectoryName
+} from '../../shared/utils';
+import { LibMoveGeneratorSchema } from './schema';
+
+export async function libMoveGenerator(tree: Tree, options: LibMoveGeneratorSchema) {
+  const { default: autocomplete } = await dynamicImport<typeof import('inquirer-autocomplete-standalone')>(
+    'inquirer-autocomplete-standalone',
+  );
+
+  const { name: srcLibraryName, path: srcLibraryPath } = await getLibraryDetailsByName(tree, options.srcLibName);
+
+  const libPathSegments = srcLibraryPath.split('/');
+  const defaultLibraryName = libPathSegments.pop();
+
+  options.app = options.app || (await selectProject(tree, 'application', 'Select the application: ')).name;
+
+  const isSharedLib = options.app === constants.sharedValue;
+
+  options.scope =
+    options.scope ||
+    (isSharedLib ? '' : await askQuestion(`Enter the scope (e.g: profile) or '${constants.sharedValue}': `));
+  options.type = options.type
+    ? validateLibraryType(options.type)
+    : await autocomplete({
+      message: 'Select the library type: ',
+      source: (input) => filterSource(input as string, Object.values(LibraryType))
+    });
+
+  const libraryName =
+    options.name ||
+    (await askQuestion(
+      'If you want to rename the library, enter its new name. Otherwise just press Enter: ',
+      defaultLibraryName,
+    ));
+  const libDirectoryName = getLibDirectoryName(libraryName, options.scope);
+  const libPath = `libs/${path.normalize(`${options.app}/${options.scope}/${options.type}/${libDirectoryName}`)}`;
+
+  execSync(`npx nx g mv --project=${srcLibraryName} --destination=${libPath}`, { stdio: 'inherit' });
+
+  return () => {
+    execSync('npx nx g lib-tags --skipRepoCheck', { stdio: 'inherit' });
+  };
+}
+
+export default libMoveGenerator;

package/src/generators/lib-remove/generator.ts

@@ -0,0 +1,25 @@
+import { Tree } from '@nx/devkit';
+import { LibRemoveGeneratorSchema } from './schema';
+import { askQuestion, selectProject } from '../../shared/utils';
+import { execSync } from 'child_process';
+
+export async function libRemoveGenerator(
+  tree: Tree,
+  options: LibRemoveGeneratorSchema
+) {
+  const libraryName = options.libName || (await selectProject(tree, 'library', 'Select the library to remove: ')).name;
+
+  if (!libraryName) {
+    throw new Error('No library found!');
+  }
+
+  const isConfirmed = await askQuestion(`Are you sure you want to remove ${libraryName} (y/n)?`);
+
+  if (!isConfirmed) {
+    return;
+  }
+
+  execSync(`npx nx g rm --project=${libraryName}`, { stdio: 'inherit' });
+}
+
+export default libRemoveGenerator;

package/src/generators/lib-rename/generator.ts

@@ -0,0 +1,25 @@
+import { execSync } from 'child_process';
+import { Tree } from '@nx/devkit';
+import { askQuestion, getLibraryDetailsByName } from '../../shared/utils';
+import { LibRenameGeneratorSchema } from './schema';
+
+export async function libRenameGenerator(tree: Tree, options: LibRenameGeneratorSchema) {
+  const { name: currentLibraryName, path: currentLibraryPath } = await getLibraryDetailsByName(
+    tree,
+    options.currentLibName,
+  );
+
+  const libPathSegments = currentLibraryPath.split('/');
+  const defaultDestLibraryName = libPathSegments.pop();
+  const destLibraryName =
+    options.newLibName || (await askQuestion('Enter a new library name: ', defaultDestLibraryName));
+
+  // Remove `libs` path fragment
+  libPathSegments.shift();
+  libPathSegments.push(destLibraryName);
+
+  const destLibraryPath = `libs/${libPathSegments.join('/')}`;
+  execSync(`npx nx g mv --project=${currentLibraryName} --destination=${destLibraryPath}`, { stdio: 'inherit' });
+}
+
+export default libRenameGenerator;

package/src/generators/lib-tags/generator.ts

@@ -0,0 +1,68 @@
+import { Tree, getProjects, ProjectConfiguration, formatFiles, output } from '@nx/devkit';
+import { LibTagsGeneratorSchema } from './schema';
+import { execSync } from 'child_process';
+import { askQuestion, getNxRules, readESLintConfig, verifyEsLintConfig } from '../../shared/utils';
+import { noop } from 'lodash';
+import { checkApplicationTags, checkLibraryTags } from './utils';
+import { LibTagsContext } from './interfaces';
+
+const context: LibTagsContext = {
+  config: {},
+  rules: [],
+  log: console.log,
+  reload: (tree: Tree) => {
+    context.config = readESLintConfig(tree).config;
+    context.rules = getNxRules(context.config);
+  }
+};
+
+export async function libTagsGenerator(
+  tree: Tree,
+  options: LibTagsGeneratorSchema,
+) {
+  const hasUnstagedChanges = !options.skipRepoCheck && execSync('git status -s').toString('utf8');
+
+  if (hasUnstagedChanges) {
+    const shouldContinue = await askQuestion('You have unstaged changes. Are you sure you want to continue? (y/n): ') === 'y';
+
+    if (!shouldContinue) {
+      return;
+    }
+  }
+
+  if (options.silent) {
+    context.log = noop;
+  }
+
+  // #1 Check eslint config nx-boundaries rule
+  output.log({ title: output.bold('1. Checking eslint config nx-boundaries rule...') });
+  context.config = verifyEsLintConfig(tree);
+
+  // #2 Check projects tags
+  output.log({ title: output.bold('2. Checking projects tags...') });
+  const projects = getProjects(tree);
+  const applications: Array<ProjectConfiguration> = [];
+  const libraries: Array<ProjectConfiguration> = [];
+
+  context.rules = getNxRules(context.config);
+
+  projects.forEach((project) => {
+    if (project.projectType === 'application') {
+      applications.push(project);
+    }
+
+    if (project.projectType === 'library' && project.root.startsWith('libs')) {
+      libraries.push(project);
+    }
+  });
+
+  applications.forEach((application) => checkApplicationTags(application, tree, context));
+
+  context.reload(tree);
+
+  libraries.forEach((library) => checkLibraryTags(library, tree, context));
+
+  await formatFiles(tree);
+}
+
+export default libTagsGenerator;

package/src/generators/lib-tags/interfaces/context.ts

@@ -0,0 +1,9 @@
+import { Tree } from '@nx/devkit';
+import { Constraint } from '../../../shared/utils';
+
+export interface LibTagsContext {
+  config: Record<string, any>;
+  rules: Array<Constraint>;
+  log: (message: any, ...optionalParams: Array<any>) => void;
+  reload: (tree: Tree) => void;
+}

package/src/generators/lib-tags/interfaces/index.ts

@@ -0,0 +1,2 @@
+export * from './context';
+export * from './verify-tag-config';

package/src/generators/lib-tags/interfaces/verify-tag-config.ts

@@ -0,0 +1,12 @@
+import { ProjectConfiguration, Tree } from '@nx/devkit';
+import { TagType } from '../types';
+import { LibTagsContext } from './context';
+
+export interface VerifyTagConfig {
+  project: ProjectConfiguration,
+  tree: Tree,
+  tag?: string,
+  tagType: TagType,
+  context: LibTagsContext,
+  ruleNotFoundCallback?: () => void
+}

package/src/generators/lib-tags/types/index.ts

@@ -0,0 +1 @@
+export * from './tag';

package/src/generators/lib-tags/types/tag.ts

@@ -0,0 +1 @@
+export type TagType = 'app' | 'scope' | 'type';

package/src/generators/lib-tags/utils/check-lib-tags.ts

@@ -0,0 +1,143 @@
+import { ProjectConfiguration, Tree, readProjectConfiguration, updateProjectConfiguration } from '@nx/devkit';
+import { addNxAppTag, addNxScopeTag, constants } from '../../../shared/utils';
+import { LibTagsContext, VerifyTagConfig } from '../interfaces';
+import { TagType } from '../types';
+
+const getTagFromLibPath = (libPath: string, type: TagType): string => {
+  const projectAppTag = libPath.split('/')[1];
+
+  switch (type) {
+    case 'app':
+      return projectAppTag;
+    case 'scope':
+      return projectAppTag === constants.sharedValue ? constants.sharedValue : libPath.split('/')[2];
+    case 'type':
+      return projectAppTag === constants.sharedValue ? libPath.split('/')[2] : libPath.split('/')[3];
+  }
+};
+
+const verifyLibraryTag = ({
+  project,
+  tree,
+  tag,
+  tagType,
+  context,
+  ruleNotFoundCallback
+}: VerifyTagConfig): void => {
+  const defaultRuleNotFoundCallback = (): void => {
+    throw new Error(`Missing ${tagType} tag rule for ${tag}. Please add it to the ESLint config file.`);
+  };
+
+  if (tag) {
+    const tagRule = context.rules.find((rule) => rule.sourceTag === tag);
+
+    if (!tagRule) {
+      const callback = ruleNotFoundCallback || defaultRuleNotFoundCallback;
+
+      callback();
+    }
+
+    const tagFromLibPath = getTagFromLibPath(project.root, tagType);
+    const isInvalidTag = tag !== `${tagType}:${tagFromLibPath}`;
+
+    if (isInvalidTag) {
+      context.log(`Invalid tag ${tag}. Updating...\n`);
+
+      project = readProjectConfiguration(tree, project.name as string);
+
+      const filteredTags = project.tags?.filter((item) => item !== tag) || [];
+
+      project.tags = [...filteredTags, `${tagType}:${tagFromLibPath}`];
+
+      updateProjectConfiguration(tree, project.name as string, project);
+
+      if (tagType === 'scope') {
+        addNxScopeTag(tree,  tagFromLibPath);
+        context.reload(tree);
+      }
+
+      verifyLibraryTag({
+        project,
+        tree,
+        tag:`${tagType}:${tagFromLibPath}`,
+        tagType,
+        context
+      });
+    }
+  } else {
+    context.log(`Missing ${tagType} tag for ${project.name}. Adding...`);
+
+    project = readProjectConfiguration(tree, project.name as string);
+
+    const tag = getTagFromLibPath(project.root, tagType);
+
+    if (tagType === 'type') {
+      const typeTagRule = context.rules.find((rule) => rule.sourceTag === `type:${tag}`);
+
+      if (!typeTagRule) {
+        throw new Error(`Missing type tag rule for ${tag}. Please add it to the ESLint config file.`);
+      }
+    }
+
+    updateProjectConfiguration(tree, project.name as string, { ...project, tags: [...(project.tags || []), `${tagType}:${tag}`] });
+
+    if (tagType === 'scope') {
+      addNxScopeTag(tree,  tag);
+      context.reload(tree);
+    }
+  }
+};
+
+export const checkApplicationTags = (project: ProjectConfiguration, tree: Tree, context: LibTagsContext): void => {
+  const { tags } = project;
+  const appTag = tags?.find((tag) => tag.startsWith('app:'));
+  const hasTypeTag = tags?.includes('type:app');
+
+  if (appTag) {
+    const appTagRule = context.rules.find((rule) => rule.sourceTag === appTag);
+
+    if (!appTagRule) {
+      context.log(`Missing app tag rule for ${appTag}. Adding...\n`);
+      addNxAppTag(tree, appTag.replace('app:', ''));
+      context.reload(tree);
+    }
+  } else {
+    context.log(`Missing app tag for ${project.name}. Adding...`);
+
+    const projectAppTag = project.root.split('/').pop() as string;
+
+    updateProjectConfiguration(tree, project.name as string, { ...project, tags: [...(project.tags || []), `app:${projectAppTag}`] });
+    addNxAppTag(tree,  projectAppTag);
+    context.reload(tree);
+  }
+
+  if (!hasTypeTag) {
+    context.log(`Missing type tag for ${project.name}. Adding...`);
+
+    project = readProjectConfiguration(tree, project.name as string);
+
+    updateProjectConfiguration(tree, project.name as string, { ...project, tags: [...(project.tags || []), 'type:app'] });
+  }
+};
+
+export const checkLibraryTags = (project: ProjectConfiguration, tree: Tree, context: LibTagsContext): void => {
+  const { tags } = project;
+  const appTag = tags?.find((tag) => tag.startsWith('app:'));
+  const scopeTag = tags?.find((tag) => tag.startsWith('scope:'));
+  const typeTag = tags?.find((tag) => tag.startsWith('type:'));
+
+  verifyLibraryTag({ project, tree, tag: appTag, tagType: 'app', context });
+  verifyLibraryTag({
+    project,
+    tree,
+    tag: scopeTag,
+    tagType:'scope',
+    context,
+    ruleNotFoundCallback:() => {
+      context.log(`Missing scope tag rule for ${scopeTag}. Adding...`);
+      addNxScopeTag(tree, scopeTag?.replace('scope:', '') as string);
+      context.reload(tree);
+    }
+  });
+  verifyLibraryTag({ project, tree, tag: typeTag, tagType: 'type', context });
+};

package/src/generators/next-app/generator.ts

@@ -0,0 +1,99 @@
+import { execSync } from 'child_process';
+import {
+  addDependenciesToPackageJson,
+  formatFiles,
+  generateFiles,
+  installPackagesTask,
+  readJson,
+  Tree,
+  writeJson,
+} from '@nx/devkit';
+import { NextAppGeneratorSchema } from './schema';
+import { existsSync } from 'fs';
+import { dependencies } from '../../shared/dependencies';
+import { BaseGeneratorType } from '../../shared/enums';
+import { runApiClientGenerator, runAppEnvGenerator, runFormUtilsGenerator, runStoreGenerator } from '../../shared/generators';
+import { addNxAppTag, askQuestion, formatName } from '../../shared/utils';
+import * as path from 'path';
+
+export async function nextAppGenerator(
+  tree: Tree,
+  options: NextAppGeneratorSchema,
+) {
+  const shouldGenerateStoreLib = await askQuestion('Do you want to create store lib? (y/n): ') === 'y';
+  const shouldGenerateApiClientLib = shouldGenerateStoreLib && await askQuestion('Do you want to create api client lib? (y/n): ') === 'y';
+  const shouldGenerateFormUtilsLib = await askQuestion('Do you want to create a lib with the form utils? (y/n): ') === 'y';
+
+  const appRoot = `apps/${options.directory}`;
+  const tags = [`app:${options.directory}`, 'type:app'];
+
+  // Install @nx/next plugin
+  execSync('npx nx add @nx/next', { stdio: 'inherit' });
+
+  if (!existsSync(appRoot)) {
+    execSync(
+      `npx nx g @nx/next:app ${options.name} --directory=apps/${options.directory} --tags="${tags.join(', ')}" --linter=eslint --appDir=true --style=scss --src=false --unitTestRunner=none --e2eTestRunner=none`,
+      { stdio: 'inherit' },
+    );
+  }
+
+  // Install @nx/expo to generate libs
+  const packageJson = readJson(tree, 'package.json');
+  const hasNxExpo = !!packageJson.devDependencies['@nx/expo'];
+  if (!hasNxExpo) {
+    execSync('npx nx add @nx/expo', { stdio: 'inherit' });
+  }
+
+  await runAppEnvGenerator(tree, { ...options, baseGeneratorType: BaseGeneratorType.NEXT_APP });
+
+  if (shouldGenerateStoreLib) {
+    await runStoreGenerator(tree, { ...options, baseGeneratorType: BaseGeneratorType.NEXT_APP });
+  }
+
+  if (shouldGenerateApiClientLib) {
+    await runApiClientGenerator(tree, options);
+  }
+
+  if (shouldGenerateFormUtilsLib) {
+    await runFormUtilsGenerator(tree, options);
+  }
+
+  // Remove unnecessary files and files that will be replaced
+  tree.delete(`${appRoot}/public/.gitkeep`);
+  tree.delete(`${appRoot}/app/api`);
+  tree.delete(`${appRoot}/app/page.tsx`);
+  tree.delete(`${appRoot}/app/page.module.scss`);
+  tree.delete(`${appRoot}/app/global.css`);
+  tree.delete(`${appRoot}/app/layout.tsx`);
+  tree.delete(`${appRoot}/specs`);
+  tree.delete(`${appRoot}/.eslintrc.json`);
+
+  // Update app tsconfig.json to skip automatic reconfiguration during the first application run
+  const appTsconfigPath = `${appRoot}/tsconfig.json`;
+  const appTsconfigJson = readJson(tree, appTsconfigPath);
+  const nextTypesInclude = '.next/types/**/*.ts';
+
+  if (!appTsconfigJson.include.includes(nextTypesInclude)) {
+    appTsconfigJson.include.push(nextTypesInclude);
+    writeJson(tree, appTsconfigPath, appTsconfigJson);
+  }
+
+  // Add app files
+  generateFiles(tree, path.join(__dirname, 'files'), appRoot, {
+    ...options,
+    formatName,
+  });
+
+  addNxAppTag(tree, options.directory);
+
+  // Add dependencies
+  addDependenciesToPackageJson(tree, dependencies['next-app'], {});
+
+  await formatFiles(tree);
+
+  return () => {
+    installPackagesTask(tree);
+  };
+}
+
+export default nextAppGenerator;

package/src/generators/react-component/generator.ts

@@ -0,0 +1,80 @@
+import { existsSync } from 'fs';
+import * as path from 'path';
+import { formatFiles, generateFiles, Tree } from '@nx/devkit';
+import { kebabCase } from 'lodash';
+import {
+  appendFileContent,
+  askQuestion,
+  createCliReadline,
+  dynamicImport,
+  formatName,
+  getNxLibsPaths,
+  LibraryType,
+  searchNxLibsPaths
+} from '../../shared/utils';
+import { ReactComponentGeneratorSchema } from './schema';
+
+export async function reactComponentGenerator(tree: Tree, options: ReactComponentGeneratorSchema) {
+  const { default: autocomplete } = await dynamicImport<typeof import('inquirer-autocomplete-standalone')>(
+    'inquirer-autocomplete-standalone',
+  );
+
+  const nxLibsPaths = getNxLibsPaths([LibraryType.FEATURES, LibraryType.UI]);
+
+  const libPath = await autocomplete({
+    message: 'Enter the library path:',
+    source: async (input) => {
+      const filteredNxLibsPaths = searchNxLibsPaths(nxLibsPaths, input as string);
+
+      return filteredNxLibsPaths.map((path) => ({ value: path }));
+    }
+  });
+
+  const cliReadline = createCliReadline();
+  options.name =
+    options.name || (await askQuestion('Enter the name of the component (e.g: AppButton): ', undefined, cliReadline));
+  options.subcomponent =
+    options.subcomponent ||
+    (await askQuestion('Generate component inside components folder? (y/n): ', undefined, cliReadline)) === 'y';
+  options.withForwardRef =
+    options.withForwardRef ||
+    (await askQuestion('Generate component with forwardRef? (y/n): ', undefined, cliReadline)) === 'y';
+  cliReadline.close();
+
+  const libRootPath = `${libPath}/lib`;
+  const componentsPath = `${libRootPath}/components`;
+  const componentPath = options.subcomponent ? `${libRootPath}/components/${kebabCase(options.name)}` : libRootPath;
+  const shouldUpdateSrcIndex = !existsSync(libRootPath);
+  const shouldUpdateLibIndex = !existsSync(componentsPath) && options.subcomponent;
+
+  generateFiles(tree, path.join(__dirname, `files`), componentPath, {
+    ...options,
+    name: formatName(options.name, true)
+  });
+
+  const updateIndexes = (): void => {
+    const componentsIndexFilePath = `${libRootPath}/components/index.ts`;
+
+    if (shouldUpdateSrcIndex) {
+      appendFileContent(`${libPath}/index.ts`, `export * from './lib';\n`, tree);
+    }
+
+    if (shouldUpdateLibIndex) {
+      appendFileContent(`${libRootPath}/index.ts`, `export * from './components';\n`, tree);
+    }
+
+    if (!existsSync(componentsIndexFilePath)) {
+      tree.write(componentsIndexFilePath, `export * from './${kebabCase(options.name)}';\n`);
+    } else {
+      appendFileContent(componentsIndexFilePath, `export * from './${kebabCase(options.name)}';\n`, tree);
+    }
+  };
+
+  if (options.subcomponent) {
+    updateIndexes();
+  }
+
+  await formatFiles(tree);
+}
+
+export default reactComponentGenerator;

package/src/generators/react-lib/generator.ts

@@ -0,0 +1,86 @@
+import { execSync } from 'child_process';
+import * as path from 'path';
+import { formatFiles, generateFiles, output, Tree } from '@nx/devkit';
+import { isBoolean } from 'lodash';
+import {
+  addNxScopeTag,
+  askQuestion,
+  constants,
+  dynamicImport,
+  filterSource,
+  formatName,
+  LibraryType,
+  selectProject,
+  validateLibraryType,
+  getLibDirectoryName,
+  createCliReadline
+} from '../../shared/utils';
+import { ReactLibGeneratorSchema } from './schema';
+
+export async function reactLibGenerator(tree: Tree, options: ReactLibGeneratorSchema) {
+  const { default: autocomplete } = await dynamicImport<typeof import('inquirer-autocomplete-standalone')>(
+    'inquirer-autocomplete-standalone',
+  );
+
+  options.app = options.app || (await selectProject(tree, 'application', 'Select the application: ')).name;
+
+  const isSharedLib = options.app === constants.sharedValue;
+
+  options.scope =
+    options.scope ||
+    (isSharedLib ? '' : await askQuestion(`Enter the scope (e.g: profile) or '${constants.sharedValue}': `));
+  options.type = options.type
+    ? validateLibraryType(options.type)
+    : await autocomplete({
+      message: 'Select the library type: ',
+      source: (input) => filterSource(input as string, Object.values(LibraryType))
+    });
+
+  const cliReadline = createCliReadline();
+  options.name =
+    options.name || (await askQuestion('Enter the name of the library (e.g: settings): ', undefined, cliReadline));
+
+  if (
+    [LibraryType.FEATURES, LibraryType.UI].includes(options.type as LibraryType) &&
+    !isBoolean(options.withComponent)
+  ) {
+    options.withComponent =
+      (await askQuestion('Generate component inside lib folder? (y/n): ', undefined, cliReadline)) === 'y';
+
+    if (options.withComponent && !isBoolean(options.withComponentForwardRef)) {
+      options.withComponentForwardRef =
+        (await askQuestion('Generate component with forwardRef? (y/n): ', undefined, cliReadline)) === 'y';
+    }
+  }
+  cliReadline.close();
+
+  const scopeTag = options.scope || constants.sharedValue;
+  const tags = [`app:${options.app}`, `scope:${scopeTag}`, `type:${options.type}`];
+
+  const libDirectoryName = getLibDirectoryName(options.name, options.scope);
+  const libName = path.normalize(`${options.app}/${options.scope}/${options.type}/${libDirectoryName}`);
+  const libPath = `libs/${libName}`;
+  const command = `npx nx g @nx/expo:lib --skipPackageJson --unitTestRunner=none --tags="${tags.join(', ')}" --name=${libName} ${libPath} --linter=eslint`;
+  const commandWithOptions = options.dryRun ? command + ' --dry-run' : command;
+
+  execSync(commandWithOptions, { stdio: 'inherit' });
+
+  if (options.withComponent) {
+    const srcPath = `${libPath}/src`;
+
+    generateFiles(tree, path.join(__dirname, 'files'), srcPath, { ...options, name: formatName(options.name, true) });
+    tree.write(`${srcPath}/index.ts`, 'export * from \'./lib\';');
+  }
+
+  addNxScopeTag(tree, scopeTag);
+
+  await formatFiles(tree);
+
+  if (libDirectoryName !== options.name) {
+    output.warn({
+      title: `The library directory was changed to ${output.bold(libDirectoryName)} so that it does not start with the scope name.`
+    });
+  }
+}
+
+export default reactLibGenerator;