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

package/README.md.handlebars

@@ -0,0 +1,115 @@
+# {{packageJson.name}}
+{{#if packageJson.description ~}}
+> {{packageJson.description}}
+{{/if}}
+
+[![npm version](https://img.shields.io/npm/v/{{packageJson.name}}?style=flat-square)](https://www.npmjs.com/package/{{packageJson.name}})
+[![commitizen friendly](https://img.shields.io/badge/commitizen-friendly-brightgreen.svg?style=flat-square)](https://commitizen.github.io/cz-cli/)
+[![styled with prettier](https://img.shields.io/badge/styled_with-prettier-ff69b4.svg?style=flat-square)](https://github.com/prettier/prettier)
+![Libraries.io dependency status for latest release, scoped npm package](https://img.shields.io/librariesio/release/npm/{{packageJson.name}})
+![npm](https://img.shields.io/npm/dm/{{packageJson.name}})
+![NPM](https://img.shields.io/npm/l/{{packageJson.name}})
+
+- [Installation](#installation)
+{{#if getStartedContent ~}}
+- [Get started](#get-started)
+{{/if}}
+{{#if guidesContent ~}}
+- [Guides](#guides)
+{{/if}}
+{{#if hasGenerators ~}}
+- [Generators](#generators)
+{{/if}}
+{{#if hasExecutors ~}}
+- [Executors](#executors)
+{{/if}}
+
+# Installation
+
+**Add the package to your workspace:**
+```bash
+yarn add {{packageJson.name}}
+```
+{{#if hasPeerDependencies ~}}
+
+**Install peer dependencies:**
+```bash
+yarn add {{#each peerDependencyList}}{{this.name}}@{{this.version}} {{/each}}
+```
+{{/if}}
+{{#if hasInitGenerator ~}}
+
+**Execute the init generator:**
+```bash
+yarn nx g {{packageJson.name}}:init
+```
+{{/if}}
+{{#if hasConfigGenerator ~}}
+
+**Execute the config generator to use the package with a project:**
+```bash
+yarn nx g {{packageJson.name}}:config [project]
+```
+{{/if}}
+{{#if getStartedContent ~}}
+
+# Get started
+
+{{{getStartedContent}}}
+{{/if}}
+{{#if guidesContent ~}}
+
+# Guides
+
+{{{guidesContent}}}
+{{/if}}
+{{#if hasGenerators ~}}
+
+# Generators
+{{#each generatorList}}
+
+## {{this.name}}
+> {{this.description}}
+
+```bash
+yarn nx g {{@root.packageJson.name}}:{{this.name}}
+```
+{{#hasProperties this.schema.properties}}
+
+Option | Type | Default | Description
+--- | --- | --- | ---
+{{#each this.schema.properties}}
+{{@key}} | {{this.type}} | {{this.default}} | {{this.description}}
+{{/each}}
+{{/hasProperties}}
+{{/each}}
+{{/if}}
+{{#if hasExecutors ~}}
+
+# Executors
+{{#each executorsList}}
+
+## {{this.name}}
+> {{this.description}}
+
+**project.json**
+```json
+{
+  "targets": {
+    "{{this.name}}": {
+      "executor": "{{@root.packageJson.name}}:{{this.name}}"
+    }
+  }
+}
+```
+{{#hasProperties this.schema.properties}}
+
+Option | Type | Default | Description
+--- | --- | --- | ---
+{{#each this.schema.properties}}
+{{@key}} | {{this.type}} | {{this.default}} | {{this.description}}
+{{/each}}
+{{/hasProperties}}
+{{/each}}
+
+{{/if}}

package/jest.config.ts

@@ -0,0 +1,11 @@
+/* eslint-disable */
+export default {
+  displayName: 'plugin-angular',
+  preset: '../../../jest.preset.js',
+  setupFilesAfterEnv: [ '<rootDir>/src/test-setup.ts' ],
+  transform: {
+    '^.+\\.[tj]s$': [ 'ts-jest', { tsconfig: '<rootDir>/tsconfig.spec.json' } ],
+  },
+  moduleFileExtensions: [ 'ts', 'js', 'html' ],
+  coverageDirectory: '../../../coverage/packages/plugin/angular',
+};

package/package.json

@@ -1,17 +1,17 @@
 {
-  "version": "20.0.1-dev.1",
+  "version": "20.0.1-dev.11",
   "name": "@rxap/plugin-angular",
   "license": "GPL-3.0-or-later",
   "dependencies": {
-    "@nx/angular": "20.3.1",
-    "@nx/devkit": "20.3.1",
-    "@rxap/plugin-application": "^20.0.1-dev.0",
-    "@rxap/plugin-library": "^20.0.1-dev.1",
-    "@rxap/plugin-utilities": "^20.0.1-dev.0",
-    "@rxap/ts-morph": "^1.5.3-dev.1",
-    "@rxap/utilities": "^16.4.2-dev.0",
-    "@rxap/workspace-ts-morph": "^19.1.9-dev.1",
-    "@rxap/workspace-utilities": "^19.6.1-dev.0",
+    "@nx/angular": "20.4.0",
+    "@nx/devkit": "20.4.0",
+    "@rxap/plugin-application": "^20.0.1-dev.6",
+    "@rxap/plugin-library": "^20.1.0-dev.5",
+    "@rxap/plugin-utilities": "^20.0.1-dev.5",
+    "@rxap/ts-morph": "^1.5.3-dev.3",
+    "@rxap/utilities": "^16.4.2-dev.2",
+    "@rxap/workspace-ts-morph": "^19.1.9-dev.6",
+    "@rxap/workspace-utilities": "^19.6.1-dev.5",
     "colors": "1.4.0",
     "handlebars": "4.7.8",
     "semver": "7.5.3",
@@ -54,18 +54,5 @@
     "directory": "packages/plugin/angular"
   },
   "schematics": "./generators.json",
-  "type": "commonjs",
-  "gitHead": "af3f3615668e796c28bf20b9bc94b929e7a1e9b5",
-  "exports": {
-    "./package.json": "./package.json",
-    ".": {
-      "types": "./src/index.d.ts",
-      "default": "./src/index.js"
-    },
-    "./library": "./src/library.js",
-    "./application": "./src/application.js",
-    "./i18n": "./src/i18n.js"
-  },
-  "types": "./src/index.d.ts",
-  "main": "./src/index.js"
+  "type": "commonjs"
 }

package/project.json

@@ -0,0 +1,68 @@
+{
+  "name": "plugin-angular",
+  "$schema": "../../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "packages/plugin/angular/src",
+  "projectType": "library",
+  "tags": ["plugin", "nx", "nx-plugin", "packages"],
+  "targets": {
+    "build": {
+      "executor": "@nx/js:tsc",
+      "outputs": ["{options.outputPath}"],
+      "options": {
+        "outputPath": "dist/packages/plugin/angular",
+        "main": "packages/plugin/angular/src/index.ts",
+        "tsConfig": "packages/plugin/angular/tsconfig.lib.json",
+        "generateExportsField": true,
+        "additionalEntryPoints": [
+          "packages/plugin/angular/src/library.ts",
+          "packages/plugin/angular/src/application.ts",
+          "packages/plugin/angular/src/i18n.ts"
+        ],
+        "assets": [
+          "packages/plugin/angular/*.md",
+          {
+            "input": "./packages/plugin/angular/src",
+            "glob": "**/!(*.ts)",
+            "output": "./src"
+          },
+          {
+            "input": "./packages/plugin/angular/src",
+            "glob": "**/*.d.ts",
+            "output": "./src"
+          },
+          {
+            "input": "./packages/plugin/angular",
+            "glob": "generators.json",
+            "output": "."
+          },
+          {
+            "input": "./packages/plugin/angular",
+            "glob": "executors.json",
+            "output": "."
+          },
+          {
+            "input": "./packages/plugin/angular",
+            "glob": "migrations.json",
+            "output": "."
+          },
+          {
+            "input": "./packages/plugin/angular/src/migrations",
+            "glob": "**/!(*.ts|*.js|*.json)",
+            "output": "./src/migrations"
+          },
+          "packages/plugin/angular/docs"
+        ]
+      }
+    },
+    "lint": {
+      "options": {
+        "lintFilePatterns": [
+          "packages/plugin/angular/**/*.ts",
+          "packages/plugin/angular/package.json",
+          "packages/plugin/angular/generators.json",
+          "packages/plugin/angular/executors.json"
+        ]
+      }
+    }
+  }
+}

package/schematics.yaml

@@ -0,0 +1,6 @@
+- package: "@rxap/plugin-library"
+  name: init
+  options: {}
+- package: "@rxap/plugin-typedoc"
+  name: init-library
+  options: {}

package/src/application.ts

@@ -0,0 +1,124 @@
+import {
+  CreateNodesContextV2,
+  CreateNodesV2,
+  ProjectConfiguration,
+  TargetConfiguration,
+} from '@nx/devkit';
+import {
+  FindProjectByPath,
+  FsTree,
+} from '@rxap/workspace-utilities';
+import { Optional } from 'nx/src/project-graph/plugins';
+import { combineGlobPatterns } from 'nx/src/utils/globs';
+import { dirname } from 'path';
+import 'colors';
+
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface PluginOptions {}
+
+export function normalizeOptions(
+  options: PluginOptions | undefined,
+): PluginOptions {
+  return options ?? {};
+}
+
+export const createNodesV2: CreateNodesV2<PluginOptions> = [
+  combineGlobPatterns([
+    '**/tsconfig.app.json',
+    '**/src/main.ts',
+    '**/src/app/app.module.ts',
+    '**/src/app/app.component.ts',
+    '**/src/index.html',
+  ]),
+  async (configFilePaths, options, context) => {
+    const normalizedOptions = normalizeOptions(options);
+
+    const includedConfigFilePaths = await Promise.all(
+      configFilePaths.map(async (configFilePath) => {
+        if (
+          await shouldHaveProjectConfiguration(
+            configFilePath,
+            normalizedOptions,
+            context,
+          )
+        ) {
+          return configFilePath;
+        }
+        return undefined;
+      }),
+    ).then((configFilePathOrUndefinedList) =>
+      configFilePathOrUndefinedList.filter((value) => value !== undefined),
+    );
+
+    const results = await Promise.all(
+      includedConfigFilePaths.map(async (configFilePath) => {
+        const [ projectPath, projectConfiguration ] =
+          await createProjectConfiguration(
+            configFilePath,
+            normalizedOptions,
+            context,
+          );
+        return [ configFilePath, projectPath, projectConfiguration ] as [
+          string,
+          string,
+          Optional<ProjectConfiguration, 'root'>
+        ];
+      }),
+    );
+
+    return results.map(
+      ([ configFilePath, projectPath, projectConfiguration ]) => [
+        configFilePath,
+        {
+          projects: {
+            [projectPath]: projectConfiguration,
+          },
+        },
+      ],
+    );
+  },
+];
+
+async function shouldHaveProjectConfiguration(
+  configFilePath: string,
+  options: PluginOptions,
+  context: CreateNodesContextV2,
+): Promise<boolean> {
+  const projectPath = dirname(configFilePath);
+  const tree = new FsTree(context.workspaceRoot);
+  if (!FindProjectByPath(tree, projectPath)) {
+    // console.log(`The folder of the file '${ configFilePath }' is not the root of a project. Skipping`.yellow);
+    return false;
+  }
+  return true;
+}
+
+async function createProjectConfiguration(
+  configFilePath: string,
+  options: PluginOptions,
+  context: CreateNodesContextV2,
+): Promise<[ string, Optional<ProjectConfiguration, 'root'> ]> {
+  const projectPath = dirname(configFilePath);
+  const targets: Record<string, TargetConfiguration> = {};
+  const tree = new FsTree(context.workspaceRoot);
+  const projectConfiguration = FindProjectByPath(tree, projectPath);
+
+  if (!projectConfiguration) {
+    throw new Error(`Could not find project in '${ projectPath }'`);
+  }
+
+  targets['config'] = createConfigTarget();
+
+  return [
+    projectPath, {
+      targets,
+    },
+  ];
+}
+
+function createConfigTarget(): TargetConfiguration {
+  return {
+    executor: '@rxap/plugin-angular:config',
+    dependsOn: ['build'],
+  };
+}

package/src/executors/check-ng-package/executor.ts

@@ -0,0 +1,33 @@
+import { ExecutorContext } from '@nx/devkit';
+import { readFileFromProjectRoot } from '@rxap/plugin-utilities';
+import { CheckNgPackageExecutorSchema } from './schema';
+
+export default async function runExecutor(
+  options: CheckNgPackageExecutorSchema,
+  context: ExecutorContext,
+) {
+  console.log('Executor ran for CheckNgPackage', options);
+
+  const ngPackage = JSON.parse(readFileFromProjectRoot(context, 'ng-package.json', true));
+  const { dependencies } = JSON.parse(readFileFromProjectRoot(context, 'package.json', true));
+
+  if (ngPackage.allowedNonPeerDependencies) {
+    const wrongPackages: string[] = [];
+    for (const packageName of ngPackage.allowedNonPeerDependencies) {
+      if (!dependencies[packageName]) {
+        wrongPackages.push(packageName);
+      }
+    }
+    if (wrongPackages.length) {
+      console.log(`\x1b[31mSome packages in the allowed non peer dependencies list are not in the package.json dependencies list:\x1b[0m\n - ${ wrongPackages.join(
+        '\n - ') }`);
+      return {
+        success: false,
+      };
+    }
+  }
+
+  return {
+    success: true,
+  };
+}

package/src/executors/config/executor.ts

@@ -0,0 +1,74 @@
+import { ExecutorContext } from '@nx/devkit';
+import { GuessOutputPathFromContext } from '@rxap/plugin-utilities';
+import {
+  deepMerge,
+  SetToObject,
+} from '@rxap/utilities';
+import {
+  existsSync,
+  readFileSync,
+  writeFileSync,
+} from 'fs';
+import { join } from 'path';
+import { ConfigExecutorSchema } from './schema';
+import 'colors';
+
+function getContent(key: string) {
+  const value = process.env[key];
+  if (value) {
+    let content: string;
+    if (value.match(/^(\/[^/\s]*)+\/?$/)) {
+      content = readFileSync(value).toString('utf-8');
+    } else {
+      content = value;
+    }
+    try {
+      return JSON.parse(content);
+    } catch (e: any) {
+      throw new Error(`Can not parse config from '${ key }': ${ content }`);
+    }
+  }
+}
+
+
+export default async function runExecutor(
+  options: ConfigExecutorSchema,
+  context: ExecutorContext,
+) {
+  console.log('Executor ran for Config', options);
+
+  const outputPath = GuessOutputPathFromContext(context);
+
+  let config: any = {};
+  const configPath = join(outputPath, 'config.json');
+  if (existsSync(configPath)) {
+    config = JSON.parse(readFileSync(configPath, 'utf-8'));
+  }
+
+  for (const key of Object.keys(process.env).filter(key => !!key && key.startsWith('RXAP_CONFIG')).sort((a, b) => a.length - b.length)) {
+    try {
+      const content = getContent(key);
+      const match = key.match(/^RXAP_CONFIG_(.*)/);
+      if (match) {
+        const key = match[1].toLowerCase().replace(/_/g, '.');
+        console.log(`Set config '${ key }'`.grey);
+        SetToObject(config, key, content);
+      } else {
+        console.log('Merge config'.grey);
+        deepMerge(config, content);
+      }
+    } catch (e: any) {
+      console.error(e.message);
+      return {
+        success: false,
+        error: e.message,
+      };
+    }
+  }
+
+  writeFileSync(configPath, JSON.stringify(config, null, 2));
+
+  return {
+    success: true,
+  };
+}

package/src/executors/i18n/executor.ts

@@ -0,0 +1,198 @@
+import { ExecutorContext } from '@nx/devkit';
+import {
+  GetProjectSourceRoot,
+  GetProjectTargetOptions,
+  GuessOutputPathFromTargetString,
+} from '@rxap/plugin-utilities';
+import {
+  existsSync,
+  readFileSync,
+  writeFileSync,
+} from 'fs';
+import { copy } from 'fs-extra';
+import { glob } from 'glob';
+import { compile } from 'handlebars';
+import {
+  basename,
+  join,
+  relative,
+} from 'path';
+import { I18nExecutorSchema } from './schema';
+
+function getIndexHtmlTemplateFilePath(indexHtmlTemplate: string, context: ExecutorContext) {
+  if (existsSync(join(context.root, indexHtmlTemplate))) {
+    return join(context.root, indexHtmlTemplate);
+  }
+  if (existsSync(join(context.root, 'shared', indexHtmlTemplate))) {
+    return join(context.root, 'shared', indexHtmlTemplate);
+  }
+  if (existsSync(join(context.root, 'shared', 'angular', indexHtmlTemplate))) {
+    return join(context.root, 'shared', 'angular', indexHtmlTemplate);
+  }
+  const projectSourceRoot = GetProjectSourceRoot(context);
+  if (existsSync(join(projectSourceRoot, indexHtmlTemplate))) {
+    return join(projectSourceRoot, indexHtmlTemplate);
+  }
+  throw new Error(`Could not find the i18n index html template with path '${ indexHtmlTemplate }'`);
+}
+
+async function createIndexHtml(
+  options: I18nExecutorSchema,
+  context: ExecutorContext,
+  outputPath: string,
+) {
+  const indexHtmlTemplateFilePath = options.indexHtmlTemplate ?? 'i18n.index.html.hbs';
+
+  if (!indexHtmlTemplateFilePath) {
+    throw new Error('The i18n index html template path is not defined');
+  }
+
+  const indexHtmlTemplateAbsoluteFilePath = getIndexHtmlTemplateFilePath(indexHtmlTemplateFilePath, context);
+
+  const indexHtmlTemplateFile = readFileSync(indexHtmlTemplateAbsoluteFilePath).toString('utf-8');
+
+  const indexHtmlTemplate = compile(indexHtmlTemplateFile);
+
+  const indexHtml = indexHtmlTemplate(options);
+
+  const indexHtmlFilePath = join(context.root, outputPath, 'index.html');
+
+  if (existsSync(indexHtmlFilePath)) {
+    console.warn(`The index.html file already exists in the location: '${ indexHtmlFilePath }'`);
+  }
+
+  writeFileSync(indexHtmlFilePath, indexHtml);
+}
+
+async function copyFiles(
+  outputPath: string,
+  pathList: Array<string | { glob: string, input: string, output: string }>,
+) {
+  await Promise.all(pathList.map(async assetPath => {
+    if (typeof assetPath === 'string') {
+      if (!outputPath) {
+        throw new Error('The i18n output path is not defined');
+      }
+      const assetOutputPath = join(outputPath, basename(assetPath));
+      try {
+        await copy(assetPath, assetOutputPath);
+      } catch (e: any) {
+        throw new Error(`Could not copy assets '${ assetPath }' to '${ outputPath }': ${ e.message }`);
+      }
+    } else {
+      if (!outputPath) {
+        throw new Error('The i18n output path is not defined');
+      }
+      const assetOutputPath = join(outputPath, assetPath.output);
+      try {
+        const files = await glob(assetPath.input + assetPath.glob);
+        await Promise.all(files.map(file => copy(file, join(assetOutputPath, relative(assetPath.input, file)))));
+      } catch (e: any) {
+        throw new Error(`Could not copy assets '${ JSON.stringify(assetPath) }' to '${ outputPath }': ${ e.message }`);
+      }
+    }
+  }));
+}
+
+async function copyAssets(
+  outputPath: string,
+  options: I18nExecutorSchema,
+  context: ExecutorContext,
+) {
+
+  if (Array.isArray(options.assets) && options.assets.length) {
+    await copyFiles(outputPath, options.assets);
+  } else if (typeof options.assets === 'boolean' && options.assets) {
+
+    if (!context.target) {
+      throw new Error('The current builder target is not defined in the context');
+    }
+
+    if (!context.projectName) {
+      throw new Error('The current project name is not defined in the context');
+    }
+
+    const buildOptions = GetProjectTargetOptions(context, context.projectName, 'build');
+
+    if (Array.isArray(buildOptions.assets) && buildOptions.assets.length) {
+      await copyFiles(outputPath, buildOptions.assets);
+    } else {
+      console.info('Skip assets copy. The build target of this project has no assets specified.');
+    }
+
+  } else {
+    console.info('Skip assets copy. No assets specified.');
+  }
+
+}
+
+function coerceDefaultLanguage(options: I18nExecutorSchema) {
+  options.defaultLanguage ??= options.availableLanguages?.[0];
+}
+
+function coerceAvailableLanguages(options: I18nExecutorSchema, context: ExecutorContext) {
+
+  if (!options.availableLanguages) {
+    const buildTarget = options.buildTarget ?? context.projectName + ':build';
+    const targetName = buildTarget.split(':')[1];
+    const buildOptions = GetProjectTargetOptions(
+      context,
+      context.projectName,
+      targetName,
+      context.configurationName ?? 'production'
+    );
+    const localize = buildOptions.localize;
+    if (localize && Array.isArray(localize) && localize.length) {
+      options.availableLanguages = localize;
+    } else if (options.defaultLanguage) {
+      options.availableLanguages = [ options.defaultLanguage ];
+    }
+
+  }
+
+}
+
+export default async function runExecutor(
+  options: I18nExecutorSchema,
+  context: ExecutorContext,
+) {
+  console.log('Executor ran for I18n', options);
+
+  coerceAvailableLanguages(options, context);
+
+  if (!options.availableLanguages?.length) {
+    throw new Error('The available languages are not defined');
+  }
+
+  coerceDefaultLanguage(options);
+
+  if (!options.defaultLanguage) {
+    throw new Error('The default language is not defined');
+  }
+
+  const outputPath = GuessOutputPathFromTargetString(context, options.buildTarget);
+
+  try {
+    await createIndexHtml(options, context, outputPath);
+  } catch (e: any) {
+    console.error(`Create index html failed: ${e.message}`);
+    return {
+      success: false,
+      error: e.message,
+    };
+  }
+
+  try {
+    await copyAssets(outputPath, options, context);
+  } catch (e: any) {
+    console.error(`Copy assets failed: ${ e.message }`);
+    return {
+      success: false,
+      error: e.message,
+    };
+  }
+
+  return {
+    success: true,
+  };
+}