@ronas-it/nx-generators 0.10.2 → 0.10.4

package/src/shared/generators/auth/generator.ts

@@ -0,0 +1,100 @@
+import { execSync } from 'child_process';
+import { existsSync } from 'fs';
+import * as path from 'path';
+import { addDependenciesToPackageJson, formatFiles, generateFiles, installPackagesTask, Tree } from '@nx/devkit';
+import { IndentationText, Project, QuoteKind, StructureKind, SyntaxKind } from 'ts-morph';
+import { dependencies, devDependencies } from '../../dependencies';
+import { formatName, formatAppIdentifier, searchAliasPath, getImportPathPrefix } from '../../utils';
+import { AuthGeneratorSchema } from './schema';
+
+const updateStore = (libRoot: string): void => {
+  const project = new Project({
+    manipulationSettings: {
+      indentationText: IndentationText.TwoSpaces,
+      quoteKind: QuoteKind.Single,
+    },
+  });
+
+  const storePath = `${libRoot}/shared/data-access/store/src`;
+  const apiPath = `${libRoot}/shared/data-access/api/src`;
+  const authPath = `${libRoot}/shared/data-access/auth/src`;
+  const store = project.addSourceFileAtPath(`${storePath}/store.ts`);
+  const apiAlias = searchAliasPath(apiPath);
+  const authAlias = searchAliasPath(authPath);
+
+  if (!apiAlias) {
+    throw new Error('Could not find API library.');
+  }
+
+  if (!authAlias) {
+    throw new Error('Could not find Auth library.');
+  }
+
+  store.addImportDeclarations([
+    { moduleSpecifier: apiAlias, namedImports: ['authApi', 'profileApi'] },
+    { moduleSpecifier: authAlias, namedImports: ['authListenerMiddleware', 'authReducer', 'authReducerPath'] },
+  ]);
+
+  const rootReducer = store.getVariableDeclarationOrThrow('rootReducer');
+
+  rootReducer.getInitializerIfKindOrThrow(SyntaxKind.ObjectLiteralExpression).addProperties([
+    { name: '[authApi.reducerPath]', initializer: 'authApi.reducer', kind: StructureKind.PropertyAssignment },
+    { name: '[authReducerPath]', initializer: 'authReducer', kind: StructureKind.PropertyAssignment },
+    { name: '[profileApi.reducerPath]', initializer: 'profileApi.reducer', kind: StructureKind.PropertyAssignment },
+  ]);
+
+  const middlewares = store.getVariableDeclarationOrThrow('middlewares');
+
+  middlewares
+    .getInitializerIfKindOrThrow(SyntaxKind.ArrayLiteralExpression)
+    .addElements(['authApi.middleware', 'authListenerMiddleware.middleware', 'profileApi.middleware'], {
+      useNewLines: true,
+    });
+
+  project.saveSync();
+};
+
+export async function runAuthGenerator(tree: Tree, options: AuthGeneratorSchema) {
+  const appRoot = `apps/${options.directory}`;
+  const libRoot = `libs/${options.directory}`;
+  const libPath = `${getImportPathPrefix(tree)}/${options.directory}`;
+
+  // Generate shared libs
+  execSync(`npx nx g react-lib --app=${options.directory} --scope=shared --type=data-access --name=api`, {
+    stdio: 'inherit',
+  });
+  execSync(`npx nx g react-lib --app=${options.directory} --scope=shared --type=data-access --name=auth`, {
+    stdio: 'inherit',
+  });
+
+  const appPackagePath = `${appRoot}/package.json`;
+
+  // Remove unnecessary files and files that will be replaced
+  tree.delete(`${libRoot}/shared/data-access/api/src/index.ts`);
+  tree.delete(`${libRoot}/shared/data-access/auth/src/index.ts`);
+
+  // Add lib files
+  generateFiles(tree, path.join(__dirname, '/lib-files'), libRoot, {
+    ...options,
+    formatName,
+    formatAppIdentifier,
+    formatDirectory: () => libPath,
+  });
+
+  updateStore(libRoot);
+
+  // Add dependencies
+  addDependenciesToPackageJson(tree, dependencies['auth'], devDependencies['auth']);
+
+  if (existsSync(appPackagePath)) {
+    addDependenciesToPackageJson(tree, dependencies['auth'], devDependencies['auth'], appPackagePath);
+  }
+
+  await formatFiles(tree);
+
+  return (): void => {
+    installPackagesTask(tree);
+  };
+}
+
+export default runAuthGenerator;

package/src/shared/generators/form-utils/generator.ts

@@ -0,0 +1,22 @@
+import { execSync } from 'child_process';
+import * as path from 'path';
+import { formatFiles, generateFiles, Tree } from '@nx/devkit';
+
+export async function runFormUtilsGenerator(tree: Tree, options: { directory: string }): Promise<void> {
+  const libRoot = `libs/${options.directory}`;
+
+  // Generate shared libs
+  execSync(`npx nx g react-lib --app=${options.directory} --scope=shared --type=utils --name=form`, {
+    stdio: 'inherit',
+  });
+
+  // Remove unnecessary files and files that will be replaced
+  tree.delete(`${libRoot}/shared/utils/form/src/index.ts`);
+
+  // Add lib files
+  generateFiles(tree, path.join(__dirname, '/lib-files'), libRoot, {});
+
+  await formatFiles(tree);
+}
+
+export default runFormUtilsGenerator;

package/src/shared/generators/rn-styles/generator.ts

@@ -0,0 +1,44 @@
+import { execSync } from 'child_process';
+import { existsSync } from 'fs';
+import * as path from 'path';
+import { addDependenciesToPackageJson, formatFiles, generateFiles, Tree } from '@nx/devkit';
+import { dependencies } from '../../dependencies';
+import { formatName, formatAppIdentifier, getImportPathPrefix } from '../../utils';
+
+export async function runRNStylesGenerator(tree: Tree, options: { name: string; directory: string }): Promise<void> {
+  const appRoot = `apps/${options.directory}`;
+  const libRoot = `libs/${options.directory}`;
+  const libPath = `${getImportPathPrefix(tree)}/${options.directory}`;
+
+  // Generate shared libs
+  execSync(
+    `npx nx g react-lib --app=${options.directory} --scope=shared --type=ui --name=styles --withComponent=false`,
+    {
+      stdio: 'inherit',
+    },
+  );
+
+  const appPackagePath = `${appRoot}/package.json`;
+
+  // Remove unnecessary files and files that will be replaced
+  tree.delete(`${libRoot}/shared/ui/styles/src/index.ts`);
+
+  // Add lib files
+  generateFiles(tree, path.join(__dirname, 'lib-files'), libRoot, {
+    ...options,
+    formatName,
+    formatAppIdentifier,
+    formatDirectory: () => libPath,
+  });
+
+  // Add dependencies
+  addDependenciesToPackageJson(tree, dependencies['rn-styles'], {});
+
+  if (existsSync(appPackagePath)) {
+    addDependenciesToPackageJson(tree, dependencies['rn-styles'], {}, appPackagePath);
+  }
+
+  await formatFiles(tree);
+}
+
+export default runRNStylesGenerator;

package/src/shared/generators/storage/generator.ts

@@ -0,0 +1,29 @@
+import { execSync } from 'child_process';
+import * as path from 'path';
+import { formatFiles, generateFiles, Tree } from '@nx/devkit';
+import { formatName, formatAppIdentifier, getImportPathPrefix } from '../../utils';
+
+export async function runStorageGenerator(tree: Tree, options: { name: string; directory: string }): Promise<void> {
+  const libRoot = `libs/${options.directory}`;
+  const libPath = `${getImportPathPrefix(tree)}/${options.directory}`;
+
+  // Generate shared libs
+  execSync(`npx nx g react-lib --app=${options.directory} --scope=shared --type=data-access --name=storage`, {
+    stdio: 'inherit',
+  });
+
+  // Remove unnecessary files and files that will be replaced
+  tree.delete(`${libRoot}/shared/data-access/storage/src/index.ts`);
+
+  // Add lib files
+  generateFiles(tree, path.join(__dirname, '/lib-files'), libRoot, {
+    ...options,
+    formatName,
+    formatAppIdentifier,
+    formatDirectory: () => libPath,
+  });
+
+  await formatFiles(tree);
+}
+
+export default runStorageGenerator;

package/src/shared/generators/store/generator.ts

@@ -0,0 +1,42 @@
+import { execSync } from 'child_process';
+import { existsSync } from 'fs';
+import * as path from 'path';
+import { addDependenciesToPackageJson, formatFiles, generateFiles, Tree } from '@nx/devkit';
+import { dependencies } from '../../dependencies';
+import { formatName, formatAppIdentifier, getImportPathPrefix } from '../../utils';
+import { StoreGeneratorSchema } from './schema';
+
+export async function runStoreGenerator(tree: Tree, options: StoreGeneratorSchema): Promise<void> {
+  const appRoot = `apps/${options.directory}`;
+  const libRoot = `libs/${options.directory}`;
+  const libPath = `${getImportPathPrefix(tree)}/${options.directory}`;
+
+  // Generate shared libs
+  execSync(`npx nx g react-lib --app=${options.directory} --scope=shared --type=data-access --name=store`, {
+    stdio: 'inherit',
+  });
+
+  const appPackagePath = `${appRoot}/package.json`;
+
+  // Remove unnecessary files and files that will be replaced
+  tree.delete(`${libRoot}/shared/data-access/store/src/index.ts`);
+
+  // Add lib files
+  generateFiles(tree, path.join(__dirname, `${options.baseGeneratorType}/lib-files`), libRoot, {
+    ...options,
+    formatName,
+    formatAppIdentifier,
+    formatDirectory: () => libPath,
+  });
+
+  // Add dependencies
+  addDependenciesToPackageJson(tree, dependencies['store'], {});
+
+  if (existsSync(appPackagePath)) {
+    addDependenciesToPackageJson(tree, dependencies['store'], {}, appPackagePath);
+  }
+
+  await formatFiles(tree);
+}
+
+export default runStoreGenerator;

package/src/shared/generators/store/schema.d.ts

@@ -1,4 +1,4 @@
-import { BaseGeneratorType } from '../enums/base-generator-type';
+import { BaseGeneratorType } from '../../enums/base-generator-type';
 
 export interface StoreGeneratorSchema {
   name: string;

package/src/shared/generators/ui-kitten/generator.ts

@@ -0,0 +1,51 @@
+import { execSync } from 'child_process';
+import { existsSync } from 'fs';
+import * as path from 'path';
+import { addDependenciesToPackageJson, formatFiles, generateFiles, Tree } from '@nx/devkit';
+import { dependencies } from '../../dependencies';
+import { formatName, formatAppIdentifier, getImportPathPrefix, LibraryType } from '../../utils';
+
+export async function runUIKittenGenerator(tree: Tree, options: { name: string; directory: string }): Promise<void> {
+  const appRoot = `apps/${options.directory}`;
+  const libRoot = `libs/${options.directory}`;
+  const libPath = `${getImportPathPrefix(tree)}/${options.directory}`;
+
+  // Generate shared libs
+  execSync(
+    `npx nx g react-lib --app=${options.directory} --scope=shared --type=${LibraryType.FEATURES} --name=user-theme-provider --withComponent=false`,
+    {
+      stdio: 'inherit',
+    },
+  );
+
+  const appPackagePath = `${appRoot}/package.json`;
+
+  // Remove unnecessary files and files that will be replaced
+  tree.delete(`${libRoot}/shared/features/user-theme-provider/src/index.ts`);
+
+  // Add lib files
+  generateFiles(tree, path.join(__dirname, 'lib-files'), libRoot, {
+    ...options,
+    formatName,
+    formatAppIdentifier,
+    formatDirectory: () => libPath,
+  });
+
+  // Update styles lib exports
+  const stylesLibIndexData = tree.read(`${libRoot}/shared/ui/styles/src/lib/index.ts`);
+  const newStylesLibIndexData =
+    stylesLibIndexData + `export * from './create-adaptive-styles';\nexport * from './eva-theme';\n`;
+
+  tree.write(`${libRoot}/shared/ui/styles/src/lib/index.ts`, newStylesLibIndexData);
+
+  // Add dependencies
+  addDependenciesToPackageJson(tree, dependencies['ui-kitten'], {});
+
+  if (existsSync(appPackagePath)) {
+    addDependenciesToPackageJson(tree, dependencies['ui-kitten'], {}, appPackagePath);
+  }
+
+  await formatFiles(tree);
+}
+
+export default runUIKittenGenerator;

package/src/shared/templates/config-template.json

@@ -17,12 +17,7 @@
           },
           {
             "sourceTag": "type:app",
-            "onlyDependOnLibsWithTags": [
-              "type:features",
-              "type:ui",
-              "type:utils",
-              "type:data-access"
-            ]
+            "onlyDependOnLibsWithTags": ["type:features", "type:ui", "type:utils", "type:data-access"]
           },
           {
             "sourceTag": "type:utils",
@@ -34,12 +29,7 @@
           },
           {
             "sourceTag": "type:features",
-            "onlyDependOnLibsWithTags": [
-              "type:features",
-              "type:data-access",
-              "type:ui",
-              "type:utils"
-            ]
+            "onlyDependOnLibsWithTags": ["type:features", "type:data-access", "type:ui", "type:utils"]
           },
           {
             "sourceTag": "type:ui",

package/src/shared/utils/cli-utils.ts

@@ -0,0 +1,164 @@
+import * as fs from 'fs';
+import * as readline from 'readline';
+import { getProjects, ProjectType, Tree } from '@nx/devkit';
+import { constants } from './constants';
+import { dynamicImport } from './dynamic-import';
+
+export const createCliReadline = (): readline.Interface =>
+  readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+export const askQuestion = (
+  question: string,
+  defaultAnswer?: string,
+  cliReadline?: readline.Interface,
+): Promise<string> => {
+  const rl = cliReadline || createCliReadline();
+
+  if (defaultAnswer) {
+    rl.write(defaultAnswer);
+    // Move cursor to end of the line
+    setTimeout(() => rl.write(null, { ctrl: true, name: 'e' }));
+  }
+
+  return new Promise((resolve) =>
+    rl.question(question, (answer) => {
+      if (!cliReadline) {
+        rl.close();
+      }
+      resolve(answer);
+    }),
+  );
+};
+
+export enum LibraryType {
+  UI = 'ui',
+  DATA_ACCESS = 'data-access',
+  FEATURES = 'features',
+  UTILS = 'utils',
+}
+
+const parseLibsPaths = (): Record<string, Array<string>> => {
+  let tsconfig;
+
+  if (fs.existsSync('tsconfig.base.json')) {
+    tsconfig = JSON.parse(fs.readFileSync('tsconfig.base.json', 'utf8'));
+  } else {
+    tsconfig = JSON.parse(fs.readFileSync('tsconfig.json', 'utf8'));
+  }
+
+  return tsconfig.compilerOptions.paths;
+};
+
+export const validateLibraryType = (type: string): string => {
+  const allLibraryTypes = Object.values(LibraryType);
+
+  if (!allLibraryTypes.includes(type as LibraryType)) {
+    throw new Error(`Invalid library type: ${type}.\nAvailable types: ${allLibraryTypes.join(', ')}`);
+  }
+
+  return type;
+};
+
+export const getNxLibsPaths = (types: Array<LibraryType>): Array<string> => {
+  const libs = parseLibsPaths();
+
+  return Object.values(libs)
+    .map((value) => value[0].replace('/index.ts', ''))
+    .filter((value) => types.some((type) => value.includes(type)));
+};
+
+export const searchNxLibsPaths = (
+  paths: Array<string>,
+  input: string,
+  method: 'includes' | 'startsWith' | 'endsWith' = 'includes',
+): Array<string> => {
+  return paths.filter((path) => path[method](input));
+};
+
+export const searchAliasPath = (input: string): string | undefined => {
+  const libs = parseLibsPaths();
+  const path = Object.keys(libs).find((key) => libs[key][0].includes(input));
+
+  return path;
+};
+
+export const filterSource = async (input: string, source: Array<string>): Promise<Array<{ value: string }>> => {
+  const filteredData = input
+    ? source.filter((pathname) => pathname.toLowerCase().includes(input.toLowerCase()))
+    : source;
+
+  return filteredData.map((path) => ({ value: path }));
+};
+
+export const appendFileContent = (path: string, endContent: string, tree: Tree): void => {
+  const content = tree.read(path, 'utf-8');
+  const contentUpdate = (content || '') + endContent;
+
+  tree.write(path, contentUpdate);
+};
+
+export const getProjectsDetails = (tree: Tree, projectType: ProjectType): Array<{ name: string; path: string }> =>
+  Array.from(getProjects(tree))
+    .filter(([_, project]) => project.projectType === projectType)
+    .map(([name, project]) => ({ name, path: project.root }));
+
+export const selectProject = async (
+  tree: Tree,
+  projectType: ProjectType,
+  message: string,
+): Promise<{ name: string; path: string }> => {
+  const { default: autocomplete } = await dynamicImport<typeof import('inquirer-autocomplete-standalone')>(
+    'inquirer-autocomplete-standalone',
+  );
+  const projects = getProjectsDetails(tree, projectType);
+
+  if (!projects.length) {
+    throw new Error(`No projects of type ${projectType} found.`);
+  }
+
+  return autocomplete({
+    message,
+    source: async (input) => {
+      const entries = [...projects, { name: constants.sharedValue, path: constants.sharedValue }].map((project) => ({
+        name: `${project.name} (${project.path})`,
+        value: { ...project, name: projectType === 'application' ? project.path.replace('apps/', '') : project.name },
+      }));
+
+      if (!input) {
+        return entries;
+      }
+
+      return entries.filter((entry) => entry.name.toLowerCase().includes(input.toLowerCase()));
+    },
+  });
+};
+
+export const getLibraryDetailsByName = async (
+  tree: Tree,
+  libraryName?: string,
+): Promise<{ name: string; path: string }> => {
+  let selectedLibraryName: string;
+  let selectedLibraryPath: string;
+
+  if (libraryName) {
+    selectedLibraryName = libraryName;
+
+    const library = getProjectsDetails(tree, 'library').find((library) => library.name === selectedLibraryName);
+
+    if (!library) {
+      throw new Error(`Library ${selectedLibraryName} not found`);
+    }
+
+    selectedLibraryPath = library.path;
+  } else {
+    const selectedLibrary = await selectProject(tree, 'library', 'Select the library to move: ');
+
+    selectedLibraryName = selectedLibrary.name;
+    selectedLibraryPath = selectedLibrary.path;
+  }
+
+  return { name: selectedLibraryName, path: selectedLibraryPath };
+};

package/src/shared/utils/config-utils.ts

@@ -0,0 +1,159 @@
+import { Tree, output, readJson, writeJson } from '@nx/devkit';
+import { isEmpty } from 'lodash';
+
+const defaultEsLintConfigPath = '.eslintrc.json';
+
+export interface Constraint {
+  sourceTag: string;
+  onlyDependOnLibsWithTags: Array<string>;
+}
+
+const getNxRulesEntry = (config: Record<string, any>): { files: Array<string>; rules: Record<string, any> } =>
+  config.overrides?.find((entry: { rules: { [x: string]: any } }) => !!entry.rules['@nx/enforce-module-boundaries']);
+
+export const getNxRulesEntryOrThrowError = (
+  config: Record<string, any>,
+): { files: Array<string>; rules: Record<string, any> } => {
+  if (!config) {
+    throw new Error('ESLint config not found');
+  }
+
+  const entryWithRules = getNxRulesEntry(config);
+
+  if (!entryWithRules) {
+    throw new Error(`ESLint: can't find '@nx/enforce-module-boundaries' rule`);
+  }
+
+  return entryWithRules;
+};
+
+export const getNxRulesStatus = (config: Record<string, any>): string => {
+  return getNxRulesEntryOrThrowError(config).rules['@nx/enforce-module-boundaries'][0];
+};
+
+export const getNxRules = (config: Record<string, any>): Array<Constraint> => {
+  return getNxRulesEntryOrThrowError(config).rules['@nx/enforce-module-boundaries'][1].depConstraints;
+};
+
+export const readESLintConfig = (tree: Tree): { config: Record<string, any>; path: string } => {
+  let path = defaultEsLintConfigPath;
+
+  const checkConfigExists = (path: string): void => {
+    if (!tree.exists(path)) {
+      throw new Error(`ESLint config not found: ${path}`);
+    }
+  };
+
+  checkConfigExists(path);
+
+  let config = readJson(tree, path);
+
+  if (getNxRulesEntry(config)) {
+    return { config, path };
+  }
+
+  if (config.extends?.length) {
+    path = config.extends[0];
+
+    checkConfigExists(path);
+
+    config = readJson(tree, config.extends[0]);
+  }
+
+  return { config, path };
+};
+
+const getNpmScope = (tree: Tree): string | undefined => {
+  const { name } = tree.exists('package.json') ? readJson<{ name?: string }>(tree, 'package.json') : { name: null };
+
+  return name?.startsWith('@') ? name.split('/')[0].substring(1) : undefined;
+};
+
+export const addNxAppTag = (tree: Tree, appDirectory: string): void => {
+  const { config, path } = readESLintConfig(tree);
+  const constraints = getNxRules(config);
+  const doesTagExist = !!constraints.find((constraint) => constraint.sourceTag === `app:${appDirectory}`);
+
+  if (doesTagExist) {
+    return;
+  }
+
+  constraints.push({
+    sourceTag: `app:${appDirectory}`,
+    onlyDependOnLibsWithTags: [`app:${appDirectory}`, 'app:shared'],
+  });
+
+  writeJson(tree, path, config);
+};
+
+export const addNxScopeTag = (tree: Tree, scope: string): void => {
+  const { config, path } = readESLintConfig(tree);
+  const constraints = getNxRules(config);
+  const doesTagExist = !!constraints.find((constraint) => constraint.sourceTag === `scope:${scope}`);
+
+  if (doesTagExist) {
+    return;
+  }
+
+  constraints.push({ sourceTag: `scope:${scope}`, onlyDependOnLibsWithTags: [`scope:${scope}`, 'scope:shared'] });
+
+  writeJson(tree, path, config);
+};
+
+export const getImportPathPrefix = (tree: Tree): string => {
+  const npmScope = getNpmScope(tree);
+
+  return npmScope ? `${npmScope === '@' ? '' : '@'}${npmScope}` : '';
+};
+
+export const verifyEsLintConfig = (tree: Tree): Record<string, any> => {
+  const { config, path } = readESLintConfig(tree);
+  const importantTags = [
+    'app:shared',
+    'scope:shared',
+    'type:app',
+    'type:data-access',
+    'type:features',
+    'type:ui',
+    'type:utils',
+  ];
+
+  if (!config || isEmpty(config)) {
+    throw new Error(`Failed to load ESLint config: ${path}`);
+  }
+
+  try {
+    const rulesEntry = getNxRulesEntryOrThrowError(config).rules['@nx/enforce-module-boundaries'];
+    const tags = rulesEntry[1].depConstraints.map((rule: Constraint) => rule.sourceTag);
+    const areRulesDisabled = rulesEntry[1].depConstraints.find(
+      (rule: Constraint) => rule.sourceTag === '*' && rule.onlyDependOnLibsWithTags.includes('*'),
+    );
+    const areRulesBroken = !importantTags.every((tag) => tags.includes(tag));
+
+    if (rulesEntry[0] !== 'error') {
+      rulesEntry[0] = 'error';
+    }
+
+    if (areRulesDisabled || areRulesBroken) {
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      const esLintConfigTemplate = require('../templates/config-template.json');
+      const templateRules = esLintConfigTemplate.rules['@nx/enforce-module-boundaries'];
+
+      rulesEntry[0] = templateRules[0];
+      rulesEntry[1] = templateRules[1];
+
+      writeJson(tree, path, config);
+    }
+    // TODO: use custom errors
+  } catch {
+    output.warn({ title: output.bold('ESLint config has no @nx/enforce-module-boundaries rule. Updating rules...') });
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const esLintConfigRulesTemplate = require('../templates/config-template.json');
+
+    config.overrides.push(esLintConfigRulesTemplate);
+
+    writeJson(tree, path, config);
+  }
+
+  return config;
+};

package/src/shared/utils/constants.ts

@@ -0,0 +1,3 @@
+export const constants = {
+  sharedValue: 'shared',
+};

package/src/shared/utils/dynamic-import.ts

@@ -0,0 +1,3 @@
+export const dynamicImport = new Function('specifier', 'return import(specifier)') as <T = never>(
+  specifier: string,
+) => Promise<T>;

package/src/shared/utils/format-utils.ts

@@ -0,0 +1,15 @@
+export const formatName = (value: string, withoutSpaces = false): string =>
+  value
+    .split('-')
+    .map((word) => `${word.charAt(0).toUpperCase()}${word.substring(1)}`)
+    .join(withoutSpaces ? '' : ' ');
+
+export const formatAppIdentifier = (value: string): string => value.toLowerCase().replace(/-/g, '.');
+
+export const getProjectName = (str: string): string => {
+  const parts = str.split('@');
+
+  return parts.length > 1 ? parts[1].split('/')[0] : parts[0];
+};
+
+export const getLibName = (path: string): string | undefined => path.split('/').pop();