@rxap/plugin-angular 20.0.1-dev.1 → 20.0.1-dev.11

package/src/generators/init-feature-library/init-project.ts

@@ -0,0 +1,53 @@
+import {
+  ProjectConfiguration,
+  Tree,
+} from '@nx/devkit';
+import { CoerceRoutes } from '@rxap/ts-morph';
+import { TsMorphAngularProjectTransform } from '@rxap/workspace-ts-morph';
+import {
+  CoerceProjectTags,
+  GetLibraryPathAliasName,
+  GetProjectSourceRoot,
+  UpdateProjectPackageJson,
+  UpdateTsConfigPaths,
+} from '@rxap/workspace-utilities';
+import { initProject as InitLibraryProject } from '../init-library/init-project';
+import { InitFeatureLibraryGeneratorSchema } from './schema';
+
+function coerceRoutesEntryPoint(tree: Tree, projectName: string) {
+  TsMorphAngularProjectTransform(tree, {
+    project: projectName,
+  }, (_, [sourceFile]) => {
+    CoerceRoutes(sourceFile, {});
+  }, ['routes.ts?']);
+}
+
+function addRoutesImportPathToBaseTsConfig(tree: Tree, projectName: string) {
+
+  UpdateTsConfigPaths(tree, paths => {
+    paths[`${GetLibraryPathAliasName(tree, projectName)}/routes`] = [
+      `${GetProjectSourceRoot(tree, projectName)}/lib/routes.ts`,
+    ];
+  }, { infix: 'base' });
+}
+
+export async function initProject(tree: Tree, projectName: string, project: ProjectConfiguration, options: InitFeatureLibraryGeneratorSchema) {
+  console.log(`init angular library project: ${ projectName }`);
+
+  CoerceProjectTags(project, ['feature', 'angular', 'ngx']);
+
+  // It is required to ensure that private is set to true before calling the InitLibraryProject function
+  // Is function this value will be used to determine if the library is publishable or not. And on default, a
+  // feature library is only buildable and NOT publishable
+  UpdateProjectPackageJson(tree, json => {
+    json.private ??= true;
+  }, { projectName });
+
+  await InitLibraryProject(tree, projectName, project, options);
+
+  if (options.routes) {
+    coerceRoutesEntryPoint(tree, projectName);
+    addRoutesImportPathToBaseTsConfig(tree, projectName);
+  }
+
+}

package/src/generators/init-feature-library/init-workspace.ts

@@ -0,0 +1,10 @@
+import { Tree } from '@nx/devkit';
+import { initWorkspace as InitLibraryWorkspace } from '../init-library/init-workspace';
+import { InitFeatureLibraryGeneratorSchema } from './schema';
+
+export async function initWorkspace(tree: Tree, options: InitFeatureLibraryGeneratorSchema) {
+  console.log('init angular library workspace');
+
+  await InitLibraryWorkspace(tree, options);
+
+}

package/src/generators/init-library/check-if-secondary-entrypoint-include-in-the-ts-config.ts

@@ -0,0 +1,46 @@
+import {
+  ProjectConfiguration,
+  Tree,
+} from '@nx/devkit';
+import {
+  CoerceFile,
+  ForEachSecondaryEntryPoint,
+} from '@rxap/workspace-utilities';
+import {
+  dirname,
+  join,
+  relative,
+} from 'path';
+
+export function checkIfSecondaryEntrypointIncludeInTheTsConfig(tree: Tree, project: ProjectConfiguration) {
+  const projectRoot = project.root;
+  const libTsConfigPath = join(projectRoot, 'tsconfig.lib.json');
+  const specTsConfigPath = join(projectRoot, 'tsconfig.spec.json');
+  const libTsConfig = tree.exists(libTsConfigPath) ? JSON.parse(tree.read(libTsConfigPath)!.toString('utf-8')) : null;
+  const specTsConfig = tree.exists(specTsConfigPath) ? JSON.parse(tree.read(specTsConfigPath)!.toString('utf-8')) :
+                       null;
+  for (const path of ForEachSecondaryEntryPoint(tree, projectRoot)) {
+    const folder = dirname(path);
+    const entryPoint = relative(projectRoot, folder);
+    if (entryPoint) {
+      if (libTsConfig) {
+        libTsConfig.include ??= [];
+        if (!libTsConfig.include.includes(`${ entryPoint }/**/*.ts`)) {
+          libTsConfig.include.push(`${ entryPoint }/**/*.ts`);
+        }
+      }
+      if (specTsConfig) {
+        specTsConfig.include ??= [];
+        if (!specTsConfig.include.includes(`${ entryPoint }/**/*.spec.ts`)) {
+          specTsConfig.include.push(`${ entryPoint }/**/*.spec.ts`);
+        }
+      }
+    }
+  }
+  if (libTsConfig) {
+    CoerceFile(tree, libTsConfigPath, JSON.stringify(libTsConfig, null, 2), true);
+  }
+  if (specTsConfig) {
+    CoerceFile(tree, specTsConfigPath, JSON.stringify(specTsConfig, null, 2), true);
+  }
+}

package/src/generators/init-library/cleanup.ts

@@ -0,0 +1,22 @@
+import {
+  ProjectConfiguration,
+  Tree,
+} from '@nx/devkit';
+import {
+  CoerceFile,
+  DeleteRecursive,
+} from '@rxap/workspace-utilities';
+import { join } from 'path';
+
+export function cleanup(tree: Tree, project: ProjectConfiguration, projectName: string) {
+  const projectSourceRoot = project.sourceRoot;
+
+  if (!projectSourceRoot) {
+    throw new Error(`The project ${ projectName } has no sourceRoot`);
+  }
+
+  if (tree.exists(join(projectSourceRoot, 'lib', projectName))) {
+    DeleteRecursive(tree, join(projectSourceRoot, 'lib', projectName));
+    CoerceFile(tree, join(projectSourceRoot, 'index.ts'), 'export {};', true);
+  }
+}

package/src/generators/init-library/coerce-projects.ts

@@ -0,0 +1,118 @@
+import { libraryGenerator as angularLibraryGenerator } from '@nx/angular/generators';
+import { Schema as AngularLibraryGeneratorSchema } from '@nx/angular/src/generators/library/schema';
+import { Tree } from '@nx/devkit';
+import { FixDependencies } from '@rxap/plugin-library';
+import {
+  GetDefaultGeneratorOptions,
+  GetProject,
+  GetProjectSourceRoot,
+  GetWorkspaceScope,
+  HasProject,
+  UpdateProjectPackageJson,
+  UpdateTsConfigJson,
+} from '@rxap/workspace-utilities';
+import { join } from 'path';
+import { cleanup } from './cleanup';
+import { InitLibraryGeneratorSchema } from './schema';
+
+export async function coerceProjects(tree: Tree, options: InitLibraryGeneratorSchema) {
+
+
+  const defaultOptions = GetDefaultGeneratorOptions<Partial<AngularLibraryGeneratorSchema>>(
+    tree, '@nx/angular:library');
+  const tags = (
+    defaultOptions.tags ?? ''
+  ).split(',').map(tag => tag.trim());
+  tags.push('angular');
+  tags.push('ngx');
+  defaultOptions.publishable ??= false;
+  defaultOptions.buildable ??= false;
+  defaultOptions.skipFormat ??= false;
+  defaultOptions.simpleName ??= false;
+  defaultOptions.addModuleSpec ??= false;
+  defaultOptions.skipPackageJson ??= false;
+  defaultOptions.skipPackageJson ??= false;
+  defaultOptions.routing ??= false;
+  defaultOptions.lazy ??= false;
+  defaultOptions.unitTestRunner ??= 'jest' as any;
+  defaultOptions.strict ??= true;
+  defaultOptions.linter ??= 'eslint' as any;
+  defaultOptions.standaloneConfig ??= true;
+  defaultOptions.setParserOptionsProject ??= false;
+  defaultOptions.addTailwind ??= false;
+  defaultOptions.skipModule ??= false;
+  defaultOptions.standalone ??= true;
+  defaultOptions.displayBlock ??= false;
+  defaultOptions.inlineStyle ??= false;
+  defaultOptions.inlineTemplate ??= false;
+  defaultOptions.changeDetection ??= 'OnPush';
+  defaultOptions.style ??= 'scss';
+  defaultOptions.skipTests ??= false;
+  defaultOptions.skipSelector ??= false;
+  defaultOptions.flat ??= false;
+
+  const scope = GetWorkspaceScope(tree);
+
+  for (const projectName of options.projects ?? []) {
+
+    if (!HasProject(tree, projectName)) {
+
+      let directory = projectName;
+      let customOptions: Partial<AngularLibraryGeneratorSchema> = {};
+      if (typeof options.coerce === 'object') {
+        customOptions = options.coerce;
+        if (options.coerce.directory) {
+          if (options.projects?.length === 1) {
+            directory = options.coerce.directory;
+          } else {
+            directory = join(options.coerce.directory, projectName);
+          }
+        }
+      }
+
+      const importPath = `${ scope }/${ projectName }`;
+
+      const schema: AngularLibraryGeneratorSchema = {
+        ...defaultOptions,
+        ...customOptions,
+        directory,
+        importPath,
+        name: projectName,
+        tags: tags.join(','),
+      };
+
+      await angularLibraryGenerator(tree, schema);
+
+      if (options.targets?.indexExport === false) {
+        UpdateTsConfigJson(tree, tsConfig => {
+          tsConfig.compilerOptions ??= {};
+          tsConfig.compilerOptions.paths ??= {};
+          if (tsConfig.compilerOptions.paths[importPath]) {
+            delete tsConfig.compilerOptions.paths[importPath];
+          }
+          tsConfig.compilerOptions.paths[`${ importPath }/*`] = [
+            `${ GetProjectSourceRoot(
+              tree, projectName) }/lib/*`,
+          ];
+        }, { infix: 'base' });
+      }
+
+      if (schema.buildable && !schema.publishable) {
+        UpdateProjectPackageJson(tree, packageJson => {
+          packageJson.private = true;
+        }, { projectName });
+      }
+
+      cleanup(tree, GetProject(tree, projectName), projectName);
+
+      if (schema.buildable || schema.publishable) {
+        await FixDependencies(tree, { projects: [ projectName ] });
+      }
+
+    } else {
+      console.log(`project ${ projectName } already exists`.grey);
+    }
+
+  }
+
+}

package/src/generators/init-library/coerce-tailwind-theme-scss.ts

@@ -0,0 +1,27 @@
+import {
+  ProjectConfiguration,
+  Tree,
+} from '@nx/devkit';
+import {
+  CoerceFile,
+  CoerceIgnorePattern,
+} from '@rxap/workspace-utilities';
+import { join } from 'path';
+import { hasTailwindConfig } from './has-tailwind-config';
+
+export function coerceTailwindThemeScss(tree: Tree, project: ProjectConfiguration) {
+
+  if (!project.sourceRoot) {
+    throw new Error(`The project ${ project.name } has no sourceRoot`);
+  }
+
+  const themeScssPath = join(project.sourceRoot, 'styles/theme.scss');
+  if (hasTailwindConfig(tree, project)) {
+    CoerceFile(tree, themeScssPath, '@tailwind components;\n@tailwind utilities;');
+    CoerceIgnorePattern(tree, join(project.root, '.gitignore'), [ 'theme.css' ]);
+  } else {
+    if (tree.exists(themeScssPath)) {
+      tree.delete(themeScssPath);
+    }
+  }
+}

package/src/generators/init-library/extend-angular-specific-eslint.ts

@@ -0,0 +1,37 @@
+import {
+  ProjectConfiguration,
+  Tree,
+} from '@nx/devkit';
+import {
+  CoerceFile,
+  IsRxapRepository,
+} from '@rxap/workspace-utilities';
+import { relative } from 'path';
+
+export function extendAngularSpecificEslint(tree: Tree, project: ProjectConfiguration) {
+
+  if (!IsRxapRepository(tree)) {
+    return;
+  }
+
+  const projectRoot = project.root;
+
+  const relativeToAngularRoot = relative(projectRoot, 'packages/angular');
+
+  const extendsPath = relativeToAngularRoot + '/.eslintrc.json';
+
+  const eslintConfigFilaPath = `${ projectRoot }/.eslintrc.json`;
+  const defaultEslintConfig = {
+    extends: [ extendsPath ],
+    ignorePatterns: [ '!**/*' ],
+    overrides: [],
+  };
+  CoerceFile(tree, eslintConfigFilaPath, JSON.stringify(defaultEslintConfig, null, 2));
+
+  const eslintConfig = JSON.parse(tree.read(eslintConfigFilaPath)!.toString('utf-8'));
+
+  if (eslintConfig.extends[0] !== extendsPath) {
+    CoerceFile(tree, eslintConfigFilaPath, JSON.stringify(defaultEslintConfig, null, 2), true);
+  }
+
+}

package/src/generators/init-library/generator.ts

@@ -0,0 +1,87 @@
+import {
+  formatFiles,
+  getProjects,
+  ProjectConfiguration,
+  Tree,
+} from '@nx/devkit';
+import { CoerceArrayItems } from '@rxap/utilities';
+import {
+  GenerateSerializedSchematicFile,
+  GetProjectRoot,
+  SkipNonAngularProject,
+  SkipNonLibraryProject,
+} from '@rxap/workspace-utilities';
+import { coerceProjects } from './coerce-projects';
+import { initProject } from './init-project';
+import { initWorkspace } from './init-workspace';
+import { InitLibraryGeneratorSchema } from './schema';
+
+function skipProject(tree: Tree, options: InitLibraryGeneratorSchema, project: ProjectConfiguration, projectName: string) {
+
+  if (options.project === projectName) {
+    return false;
+  }
+
+  if (SkipNonAngularProject(tree, options, project, projectName)) {
+    return true;
+  }
+
+  if (SkipNonLibraryProject(tree, options, project, projectName)) {
+    return true;
+  }
+
+  return false;
+
+}
+
+export async function initLibraryGenerator(
+  tree: Tree,
+  options: InitLibraryGeneratorSchema,
+) {
+  options.project ??= undefined;
+  options.projects ??= [];
+  if (options.project) {
+    CoerceArrayItems(options.projects, [options.project]);
+  }
+  if (options.indexExport !== undefined) {
+    options.targets ??= {};
+    options.targets.indexExport = options.indexExport;
+    delete options.indexExport;
+  }
+  console.log('angular library init generator:', options);
+
+  await initWorkspace(tree, options);
+
+  if (options.coerce) {
+    await coerceProjects(tree, options);
+  }
+
+  if (!options.skipProjects) {
+
+    for (const [ projectName, project ] of getProjects(tree).entries()) {
+
+      if (skipProject(tree, options, project, projectName)) {
+        continue;
+      }
+
+      GenerateSerializedSchematicFile(
+        tree,
+        GetProjectRoot(tree, projectName),
+        '@rxap/plugin-angular',
+        'init-library',
+        options,
+      );
+
+      await initProject(tree, projectName, project, options);
+
+    }
+
+  }
+
+  if (!options.skipFormat) {
+    await formatFiles(tree);
+  }
+
+}
+
+export default initLibraryGenerator;

package/src/generators/init-library/has-index-scss.ts

@@ -0,0 +1,14 @@
+import {
+  ProjectConfiguration,
+  Tree,
+} from '@nx/devkit';
+import { join } from 'path';
+
+export function hasIndexScss(tree: Tree, project: ProjectConfiguration) {
+
+  if (!project.sourceRoot) {
+    throw new Error(`The project ${ project.name } has no sourceRoot`);
+  }
+
+  return tree.exists(join(project.sourceRoot, '_index.scss'));
+}

package/src/generators/init-library/has-tailwind-config.ts

@@ -0,0 +1,9 @@
+import {
+  ProjectConfiguration,
+  Tree,
+} from '@nx/devkit';
+import { join } from 'path';
+
+export function hasTailwindConfig(tree: Tree, project: ProjectConfiguration) {
+  return tree.exists(join(project.root, 'tailwind.config.js'));
+}

package/src/generators/init-library/index.ts

@@ -0,0 +1,5 @@
+import { convertNxGenerator } from '@nx/devkit';
+import generator from './generator';
+
+const schematic = convertNxGenerator(generator);
+export default schematic;

package/src/generators/init-library/init-project.ts

@@ -0,0 +1,46 @@
+import {
+  ProjectConfiguration,
+  Tree,
+  updateProjectConfiguration,
+} from '@nx/devkit';
+import { LibraryInitProject } from '@rxap/plugin-library';
+import {
+  CoerceIgnorePattern,
+  IsBuildable,
+} from '@rxap/workspace-utilities';
+import { join } from 'path';
+import { coerceTestSetup } from '../../lib/coerce-test-setup';
+import { checkIfSecondaryEntrypointIncludeInTheTsConfig } from './check-if-secondary-entrypoint-include-in-the-ts-config';
+import { cleanup } from './cleanup';
+import { coerceTailwindThemeScss } from './coerce-tailwind-theme-scss';
+import { extendAngularSpecificEslint } from './extend-angular-specific-eslint';
+import { InitLibraryGeneratorSchema } from './schema';
+import { updatePackageJson } from './update-package-json';
+import { updateProjectNgPackageConfiguration } from './update-project-ng-package-configuration';
+import { updateTsConfig } from './update-ts-config';
+
+export async function initProject(tree: Tree, projectName: string, project: ProjectConfiguration, options: InitLibraryGeneratorSchema) {
+  console.log(`init angular library project: ${ projectName }`);
+
+  await LibraryInitProject(tree, projectName, project, options);
+
+  cleanup(tree, project, projectName);
+  updatePackageJson(tree, projectName, project);
+
+  checkIfSecondaryEntrypointIncludeInTheTsConfig(tree, project);
+
+  if (IsBuildable(project)) {
+    updateProjectNgPackageConfiguration(tree, project);
+    coerceTailwindThemeScss(tree, project);
+  }
+  extendAngularSpecificEslint(tree, project);
+  updateTsConfig(tree, projectName);
+  coerceTestSetup(tree, projectName);
+
+  updateProjectConfiguration(tree, projectName, project);
+
+  CoerceIgnorePattern(tree, join(project.root, '.eslintignore'), [
+    '.angular',
+  ]);
+
+}

package/src/generators/init-library/init-workspace.ts

@@ -0,0 +1,26 @@
+import { Tree } from '@nx/devkit';
+import { LibraryInitWorkspace } from '@rxap/plugin-library';
+import {
+  AddPackageJsonDependency,
+  IsAlreadyExecuted,
+} from '@rxap/workspace-utilities';
+import { ANGULAR_VERSION } from '../../lib/angular-version';
+import { InitLibraryGeneratorSchema } from './schema';
+import { setGeneralTargetDefaults } from './set-general-target-defaults';
+
+export async function initWorkspace(tree: Tree, options: InitLibraryGeneratorSchema) {
+
+  if (IsAlreadyExecuted([__dirname, __filename, 'initWorkspace'].join('_'))) {
+    return;
+  }
+
+  console.log('init angular library workspace');
+
+  // must always be added as some rxap components use the i18n tag
+  await AddPackageJsonDependency(tree, '@angular/localize', ANGULAR_VERSION, { soft: true });
+
+  LibraryInitWorkspace(tree, options);
+
+  setGeneralTargetDefaults(tree);
+
+}

package/src/generators/init-library/is-ng-packagr-project.ts

@@ -0,0 +1,9 @@
+import {
+  ProjectConfiguration,
+  Tree,
+} from '@nx/devkit';
+import { join } from 'path';
+
+export function isNgPackagrProject(tree: Tree, project: ProjectConfiguration) {
+  return tree.exists(join(project.root, 'ng-package.json'));
+}

package/src/generators/init-library/ng-package-json.ts

@@ -0,0 +1,23 @@
+import {
+  ProjectConfiguration,
+  readJson,
+  Tree,
+  writeJson,
+} from '@nx/devkit';
+import { Assets } from '@rxap/workspace-utilities';
+import { join } from 'path';
+
+interface NgPackageJson {
+  assets: Assets;
+}
+
+export function readNgPackageJson(tree: Tree, project: ProjectConfiguration): NgPackageJson {
+  if (!tree.exists(join(project.root, 'ng-package.json'))) {
+    throw new Error(`The project ${ project.name } has no ng-package.json file.`);
+  }
+  return readJson(tree, join(project.root, 'ng-package.json'));
+}
+
+export function writeNgPackageJson(tree: Tree, project: ProjectConfiguration, ngPackageJson: NgPackageJson) {
+  writeJson(tree, join(project.root, 'ng-package.json'), ngPackageJson);
+}

package/src/generators/init-library/set-general-target-defaults.ts

@@ -0,0 +1,36 @@
+import {
+  readNxJson,
+  Tree,
+  updateNxJson,
+} from '@nx/devkit';
+import {
+  CoerceTarget,
+  CoerceTargetDefaultsDependency,
+  IsRxapRepository,
+  Strategy,
+} from '@rxap/workspace-utilities';
+
+export function setGeneralTargetDefaults(tree: Tree) {
+  const nxJson = readNxJson(tree);
+
+  if (!nxJson) {
+    throw new Error('No nx.json found');
+  }
+
+  CoerceTarget(nxJson, '@nx/angular:ng-packagr-lite', {
+    dependsOn: [
+      'index-export', '^index-export', '^build', 'check-version', 'build-tailwind', 'check-ng-package'
+    ],
+    inputs: [ "production", "^production" ]
+  }, Strategy.OVERWRITE);
+  if (IsRxapRepository(tree)) {
+    CoerceTargetDefaultsDependency(nxJson, 'build-tailwind', {
+      target: 'build',
+      projects: [
+        'browser-tailwind',
+      ],
+    });
+  }
+
+  updateNxJson(tree, nxJson);
+}

package/src/generators/init-library/update-package-json.ts

@@ -0,0 +1,26 @@
+import {
+  ProjectConfiguration,
+  Tree,
+} from '@nx/devkit';
+import {
+  GetMajorAngularVersion,
+  IsPublishable,
+  UpdateProjectPackageJson,
+} from '@rxap/workspace-utilities';
+import { gte } from 'semver';
+
+export function updatePackageJson(
+  tree: Tree,
+  projectName: string,
+  project: ProjectConfiguration,
+) {
+  if (IsPublishable(tree, project)) {
+    UpdateProjectPackageJson(tree, packageJson => {
+      const majorAngularVersion = GetMajorAngularVersion(tree);
+      const version = `${ majorAngularVersion }.0.0-dev.0`;
+      if (!packageJson.version || gte(version, packageJson.version)) {
+        packageJson.version = version;
+      }
+    }, { projectName });
+  }
+}

package/src/generators/init-library/update-project-ng-package-configuration.ts

@@ -0,0 +1,51 @@
+import {
+  ProjectConfiguration,
+  Tree,
+} from '@nx/devkit';
+import {
+  CoerceAssets,
+  RemoveAssets,
+  ReadNgPackageJson,
+  WriteNgPackageJson,
+} from '@rxap/workspace-utilities';
+import { hasIndexScss } from './has-index-scss';
+import { hasTailwindConfig } from './has-tailwind-config';
+import {
+  readNgPackageJson,
+  writeNgPackageJson,
+} from './ng-package-json';
+
+export function updateProjectNgPackageConfiguration(tree: Tree, project: ProjectConfiguration) {
+  const ngPackageJson = ReadNgPackageJson(tree, project);
+
+  ngPackageJson.assets ??= [];
+
+  CoerceAssets(ngPackageJson.assets, [ 'README.md', 'CHANGELOG.md', 'LICENSE', 'LICENSE.md' ]);
+
+  const assetThemes = {
+    input: '.',
+    glob: '**/*.theme.scss',
+    output: '.',
+  };
+  const assetIndex = {
+    input: '.',
+    glob: '_index.scss',
+    output: '.',
+  };
+
+  const assetStyles = 'theme.css';
+
+  if (hasIndexScss(tree, project)) {
+    CoerceAssets(ngPackageJson.assets, [ assetThemes, assetIndex ]);
+  } else {
+    RemoveAssets(ngPackageJson.assets, [ assetThemes, assetIndex ]);
+  }
+
+  if (hasTailwindConfig(tree, project)) {
+    CoerceAssets(ngPackageJson.assets, [ assetStyles ]);
+  } else {
+    RemoveAssets(ngPackageJson.assets, [ assetStyles ]);
+  }
+
+  WriteNgPackageJson(tree, project, ngPackageJson);
+}