@eui/tools 5.0.0-rc.8 → 5.1.1

package/scripts/utils/pre-build/injection/app-sources-full-skeleton-eui14/src/_generated/tst.ts

@@ -0,0 +1,33 @@
+// This file is required by karma.conf.js and loads recursively all the .spec and framework files
+
+import 'zone.js/dist/long-stack-trace-zone';
+import 'zone.js/dist/proxy.js';
+import 'zone.js/dist/sync-test';
+import 'zone.js/dist/jasmine-patch';
+import 'zone.js/dist/async-test';
+import 'zone.js/dist/fake-async-test';
+import { APP_BASE_HREF } from '@angular/common';
+import { getTestBed } from '@angular/core/testing';
+import {
+  BrowserDynamicTestingModule,
+  platformBrowserDynamicTesting,
+} from '@angular/platform-browser-dynamic/testing';
+
+// Unfortunately there's no typing for the `__karma__` variable. Just declare it as any.
+declare const __karma__: any;
+declare const require: any;
+
+// Prevent Karma from running prematurely.
+__karma__.loaded = function () {};
+
+// First, initialize the Angular testing environment.
+getTestBed().initTestEnvironment(
+  BrowserDynamicTestingModule,
+  platformBrowserDynamicTesting([{ provide: APP_BASE_HREF, useValue: '/' }]),
+);
+// Then we find all the tests.
+const context = require.context('./', true, /\.spec\.ts$/);
+// And load the modules.
+context.keys().map(context);
+// Finally, start Karma to run the tests.
+__karma__.start();

package/scripts/utils/pre-build/injection/app-sources-full-skeleton-eui14/tsconfig.app.json

@@ -0,0 +1,19 @@
+{
+    "extends": "../../tsconfig.json",
+    "compilerOptions": {
+      "outDir": "./dist",
+      "types": [],
+      "module": "ESNext",
+      "target": "ES2016",
+      "lib": ["es2020", "dom"]
+    },
+    "exclude": [
+      "test.ts",
+      "**/*.spec.ts",
+      "_todo/**/*.ts",
+      "**/_todo/**/*.ts",
+      "src/assets/samples/**/*.ts",
+      "dist/assets/samples/**/*.ts"
+    ],
+    "include": ["**/*.ts"]
+  }

package/scripts/utils/pre-build/injection/app-sources-full-skeleton-eui14/tsconfig.spec.json

@@ -0,0 +1,9 @@
+{
+    "extends": "../../tsconfig.json",
+    "compilerOptions": {
+      "outDir": "./dist",
+      "types": ["jasmine", "node"]
+    },
+    "files": ["src/test.ts", "src/polyfills.ts"],
+    "include": ["**/*.spec.ts", "**/*.d.ts"]
+  }

package/scripts/utils/pre-build/injection/app-sources-full-skeleton-eui14/tslint.json

@@ -0,0 +1,17 @@
+{
+    "extends": "../../tslint.json",
+    "rules": {
+        "directive-selector": [
+            true,
+            "attribute",
+            "app",
+            "camelCase"
+        ],
+        "component-selector": [
+            true,
+            "element",
+            "app",
+            "kebab-case"
+        ]
+    }
+}

package/scripts/utils/pre-build/injection/config.js

@@ -15,42 +15,41 @@ const injectConfig = (project) => {
   return Promise.resolve()
     .then(() => {
       if (!project.config.npmPkg) {
-        return tools.logWarning('No linked config package found in project config');
+        tools.logWarning('No linked config package found in project config');
+        return;
+      }
+      // check if package is locally cloned
+      const localPackage = configUtils.packages.getPackages().filter((p) => {
+        return p.npmPkg === project.config.npmPkg
+      })[0];
 
-      } else {
-        // check if package is locally cloned
-        const localPackage = configUtils.packages.getPackages().filter((p) => {
-          return p.npmPkg === project.config.npmPkg
-        })[0];
+      var pkgAssetsPath;
+      const projectAssetsPath = path.join(process.cwd(), project.folder, 'src', 'assets');
+      const projectEnvironmentsPath = path.join(process.cwd(), project.folder, 'src', 'environments');
 
-        var pkgAssetsPath;
-        const projectAssetsPath = path.join(process.cwd(), project.folder, 'src', 'assets');
-        const projectEnvironmentsPath = path.join(process.cwd(), project.folder, 'src', 'environments');
+      // if local package is found
+      if (localPackage) {
+        pkgAssetsPath = path.join(process.cwd(), 'packages', localPackage.name, 'assets');
 
-        // if local package is found
-        if (localPackage) {
-          pkgAssetsPath = path.join(process.cwd(), 'packages', localPackage.name, 'assets');
+      // if not sources are taken from the npm package def in node_modules
+      } else {
+        const npmPkgScope = project.config.npmPkg.substr(0, project.config.npmPkg.indexOf('/'));
+        const npmPkgName = project.config.npmPkg.substr(project.config.npmPkg.indexOf('/') + 1);
+        pkgAssetsPath = path.join(process.cwd(), 'node_modules', npmPkgScope, npmPkgName, 'assets');
+      }
 
-        // if not sources are taken from the npm package def in node_modules
-        } else {
-          const npmPkgScope = project.config.npmPkg.substr(0, project.config.npmPkg.indexOf('/'));
-          const npmPkgName = project.config.npmPkg.substr(project.config.npmPkg.indexOf('/') + 1);
-          pkgAssetsPath = path.join(process.cwd(), 'node_modules', npmPkgScope, npmPkgName, 'assets');
-        }
+      if (!tools.isDirExists(pkgAssetsPath)) {
+        tools.logWarning(`Linked config pkg : ${project.config.npmPkg} cannot be found in node_modules`);
+        return;
+      }
 
-        if (!tools.isDirExists(pkgAssetsPath)) {
-          return tools.logWarning(`Linked config pkg : ${project.config.npmPkg} cannot be found in node_modules`);
+      tools.logInfo(`${project.config.npmPkg}/assets - injecting in ${projectAssetsPath}`);
+      tools.copydir(pkgAssetsPath, projectAssetsPath);
 
-        } else {
-          tools.logInfo(`${project.config.npmPkg}/assets - injecting in ${projectAssetsPath}`);
-          tools.copydir(pkgAssetsPath, projectAssetsPath);
-
-          const pkgEnvironmentsPath = path.join(pkgAssetsPath, 'environments');
-          if (tools.isDirExists(pkgEnvironmentsPath)) {
-            tools.logInfo(`${project.config.npmPkg}/assets/environments - injecting in ${projectEnvironmentsPath}`);
-            tools.copydir(pkgEnvironmentsPath, projectEnvironmentsPath);
-          }
-        }
+      const pkgEnvironmentsPath = path.join(pkgAssetsPath, 'environments');
+      if (tools.isDirExists(pkgEnvironmentsPath)) {
+        tools.logInfo(`${project.config.npmPkg}/assets/environments - injecting in ${projectEnvironmentsPath}`);
+        tools.copydir(pkgEnvironmentsPath, projectEnvironmentsPath);
       }
     })
 
@@ -71,7 +70,7 @@ const injectPackagesConfig = (project) => {
 
     // fetching current project linked composite packages dependencies
     .then(() => {
-      return installUtils.compositeUtils.getLocalProjectsDeps(project);
+      return installUtils.common.getLocalProjectsDeps(project);
     })
 
 

package/scripts/utils/pre-build/injection/externals.js

@@ -9,7 +9,7 @@ const configUtils = require('../../../csdr/config/config-utils');
 
 module.exports.injectExternalFeatures = (project) => {
 
-  tools.logInfo(`Injecting project external features for : ${project.name}`);
+  tools.logTitle(`Injecting project external features for : ${project.name}`);
 
   return Promise.resolve()
     .then(() => {
@@ -49,6 +49,9 @@ module.exports.injectExternalFeatures = (project) => {
           throw new Error('External features not found');
 
         } else {
+          tools.logInfo(`Removing ${projectSrcPath} content`);
+          tools.rmdirFull(projectSrcPath, false);
+
           tools.logInfo(`${featuresSrcPath} injecting in ${projectSrcPath}`);
           return tools.copydir(featuresSrcPath, projectSrcPath, true);
         }
@@ -63,7 +66,7 @@ module.exports.injectExternalFeatures = (project) => {
 
 module.exports.injectExternalAppSources = (project) => {
 
-  tools.logInfo(`Injecting project external application sources for : ${project.name}`);
+  tools.logTitle(`Injecting project external application sources for : ${project.name}`);
 
   return Promise.resolve()
     .then(() => {
@@ -103,8 +106,19 @@ module.exports.injectExternalAppSources = (project) => {
           throw new Error('External features not found');
 
         } else {
-          tools.logInfo(`${appSourcesSrcPath} injecting in ${projectSrcPath}`);
-          return tools.copydir(appSourcesSrcPath, projectSrcPath, true);
+          tools.logInfo(`Removing ${projectSrcPath} content`);
+
+          return Promise.resolve()
+            .then(() => {
+              return tools.rmdirFull(projectSrcPath, false);
+            })
+            .then(() => {
+              tools.logInfo(`${appSourcesSrcPath} injecting in ${projectSrcPath}`);
+              return tools.copydir(appSourcesSrcPath, projectSrcPath, true);
+            })
+            .catch((e) => {
+              throw e;
+            })
         }
       }
     })
@@ -115,94 +129,78 @@ module.exports.injectExternalAppSources = (project) => {
 }
 
 
-module.exports.injectExternalMock = (project) => {
+module.exports.injectElementExternalSources = (pkg) => {
 
-  tools.logInfo(`Injecting project external mock for : ${project.name}`);
+  tools.logTitle(`Injecting package external sources for : ${pkg.name}`);
 
   return Promise.resolve()
     .then(() => {
-      if (!(project.mock && project.mock.external)) {
-        tools.logInfo('No external mock setup...skipping')
+      if (!pkg.externalSources) {
+        tools.logInfo('No external sources setup...skipping');
+        return;
+      }
+
+      if (!pkg.externalSources.npmPkg || !pkg.externalSources.folder) {
+        return tools.logWarning('External sources use requires a source [npmPkg] and a [folder] declared');
 
       } else {
-        return gitUtils.cloneRepo(project.mock.repository, project.mock.folder);
-      }
-    })
+        // check if package is locally cloned
+        const localPackage = configUtils.packages.getPackages().filter((p) => {
+          return p.npmPkg === pkg.externalSources.npmPkg
+        })[0];
 
-    .catch((e) => {
-      throw e;
-    })
-}
+        let externalSourcesSrcPath;
+        const pkgSrcPath = path.join(pkg.paths.pkgRootDirectory, 'src');
 
-module.exports.remapRoutesByEnvConfig = (project, envTarget, build) => {
-  tools.logInfo(`Remapping routes by env config for ${envTarget}`);
+        // if local package is found
+        if (localPackage) {
+          tools.logInfo('local pkg found, copying from local');
+          externalSourcesSrcPath = path.join(process.cwd(), 'packages', localPackage.name, pkg.externalSources.folder);
 
-  return Promise.resolve()
-    .then(() => {
-      // getting config file
-      const projectAssetsPath = path.join(process.cwd(), project.folder, 'src', 'assets');
-      let configFile;
-
-      // build - envTarget based
-      if (build) {
-        let envTargetFinal = envTarget.toLowerCase();
-        // dirty fix as openid files do not respect envTarget names
-        if (envTargetFinal === 'tst') {
-          envTargetFinal = 'test';
+        // if not sources are taken from the npm package def in node_modules
+        } else {
+          tools.logInfo('remote pkg found, copying from remote');
+          const npmPkgScope = pkg.externalSources.npmPkg.substr(0, pkg.externalSources.npmPkg.indexOf('/'));
+          const npmPkgName = pkg.externalSources.npmPkg.substr(pkg.externalSources.npmPkg.indexOf('/') + 1);
+
+          externalSourcesSrcPath = path.join(pkg.paths.pkgRootDirectory, 'node_modules', npmPkgScope, npmPkgName, pkg.externalSources.folder);
         }
-        configFile = path.join(projectAssetsPath, 'openid-login-config.' + envTargetFinal + '.json');
 
-      // serve configuration based
-      } else {
-        if (envTarget.indexOf('local') > -1) {
-          configFile = path.join(projectAssetsPath, 'openid-login-config.' + envTarget.replace('-openid', '') + '.json');
+        if (!tools.isDirExists(externalSourcesSrcPath)) {
+          tools.logWarning(`External sources location : ${externalSourcesSrcPath} cannot be found in node_modules`);
+          throw new Error('External sources not found');
+
         } else {
-          configFile = path.join(projectAssetsPath, 'openid-login-config.local-' + envTarget + '.json');
+          if (tools.isDirExists(pkgSrcPath)) {
+            tools.logInfo(`Removing ${pkgSrcPath} content`);
+            tools.rmdirFull(pkgSrcPath, false);
+          }
+
+          tools.logInfo(`${externalSourcesSrcPath} injecting in ${pkgSrcPath}`);
+          return tools.copydir(externalSourcesSrcPath, pkgSrcPath, true);
         }
       }
+    })
 
-      tools.logInfo(`checking ${configFile}`);
-      if (!tools.isFileExists(configFile)) {
-        tools.logError(`config file for ${envTarget} do not exists`);
-        return;
-      }
+    .catch((e) => {
+      throw e;
+    })
+}
 
-      // getting config file content and checking if routesRemapping is set
-      const config = require(configFile);
-      const routesRemapping = config.routesRemapping;
-      if (!routesRemapping) {
-        tools.logWarning('No routes remapping found in current config...skipping');
-        return;
-      }
 
-      // checking is routes path declared
-      if (!project.appSources.routesFilePath) {
-        tools.logError('project appSources.routesFilePath is not declared in apps config');
-        return;
-      }
 
-      // checking is routes file exists
-      const routesFilePath = path.join(project.paths.rootPath, project.appSources.routesFilePath);
-      if (!tools.isFileExists(routesFilePath)) {
-        tools.logError(`Unable to find routes files : ${routesFilePath}`);
-        return;
-      }
+module.exports.injectExternalMock = (project) => {
 
-      // get routes file content and replace tokens
-      let routesFileContent = tools.getFileContent(routesFilePath);
-      routesRemapping.forEach((route) => {
-        tools.logInfo(`checking replacement for : ${JSON.stringify(route)}`);
-        // const tokenToSearch = `@${route.featureModule}.routeModuleDef@`;
-        const tokenToSearch = `./features/${route.featureModule}-lib.module#Module`;
-        if (routesFileContent.indexOf(tokenToSearch) > -1) {
-          tools.logInfo(`token ${tokenToSearch} found...replacing`);
-          routesFileContent = tools.replaceAll(routesFileContent, tokenToSearch, route.routeModuleDef);
-        }
-      })
-      return tools.writeFileContent(routesFilePath, routesFileContent);
-    })
+  tools.logTitle(`Injecting project external mock for : ${project.name}`);
+
+  return Promise.resolve()
     .then(() => {
-      tools.logSuccess();
+      if (!(project.mock && project.mock.external)) {
+        tools.logInfo('No external mock setup...skipping')
+
+      } else {
+        return gitUtils.cloneRepo(project.mock.repository, project.mock.folder);
+      }
     })
 
     .catch((e) => {

package/scripts/utils/pre-build/injection/injection-utils.js

@@ -4,8 +4,10 @@
 const innerConfig = require('./config');
 const innerSkeletons = require('./skeletons');
 const innerExternals = require('./externals');
+const innerRoutesReplacement = require('./routes-replacement');
 
 // re-exports inner modules
 module.exports.config = innerConfig;
 module.exports.skeletons = innerSkeletons;
 module.exports.externals = innerExternals;
+module.exports.routesReplacement = innerRoutesReplacement;