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

package/README.md.handlebars

@@ -1,115 +0,0 @@
-# {{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

@@ -1,11 +0,0 @@
-/* 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/project.json

@@ -1,68 +0,0 @@
-{
-  "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

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

package/src/application.ts

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

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

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

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

package/src/executors/tailwind/executor.ts

@@ -1,34 +0,0 @@
-import { ExecutorContext } from '@nx/devkit';
-import { GetProjectRoot } from '@rxap/plugin-utilities';
-import { join } from 'path';
-// @ts-expect-error - Tailwindcss does not have types
-import { build } from 'tailwindcss/lib/cli/build';
-import { TailwindExecutorSchema } from './schema';
-
-export default async function runExecutor(options: TailwindExecutorSchema, context: ExecutorContext) {
-  console.log('Executor ran for Tailwind', options);
-
-  const projectRoot = GetProjectRoot(context);
-
-  const args: Record<string, string | boolean | number> = {
-    '--config': join(projectRoot, options.config),
-    '--input': join(projectRoot, options.input),
-    '--output': join(projectRoot, options.output),
-  };
-
-  if (options.minify) {
-    args['--minify'] = true;
-  }
-
-  console.log('Running Tailwind with args', JSON.stringify(args, undefined, 2));
-
-  await build(args);
-
-  return { success: true };
-
-  // return run({
-  //   cwd: projectRoot,
-  //   command,
-  //   __unparsed__: [],
-  // }, context);
-}