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

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

@@ -1,53 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,118 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,87 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

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

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

@@ -1,46 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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);
-}