@redhat-cloud-services/frontend-components-config-utilities 1.5.9 → 1.5.10

package/chrome-render-loader.js

@@ -1,8 +1,8 @@
 /* eslint-disable max-len */
 function chromeRenderLoader(source) {
-    const loaderUtils = require('loader-utils');
-    const options = loaderUtils.getOptions(this);
-    return `document.getElementById('root').classList.add('${options.appName}');var isChrome2 = (!${options.skipChrome2} && window.insights && window.insights.chrome && window.insights.chrome.isChrome2) || false; if(!isChrome2){${source}}`;
+  const loaderUtils = require('loader-utils');
+  const options = loaderUtils.getOptions(this);
+  return `document.getElementById('root').classList.add('${options.appName}');var isChrome2 = (!${options.skipChrome2} && window.insights && window.insights.chrome && window.insights.chrome.isChrome2) || false; if(!isChrome2){${source}}`;
 }
 
 module.exports = chromeRenderLoader;

package/chrome-render-loader.test.js

@@ -1,44 +1,44 @@
 import chromeRenderLoader from './chrome-render-loader';
 
 jest.mock('loader-utils', () => ({
-    getOptions: jest.fn().mockImplementation((that) => {
-        return that.options;
-    })
+  getOptions: jest.fn().mockImplementation((that) => {
+    return that.options;
+  }),
 }));
 
 describe('chromeRenderLoader', () => {
-    beforeAll(() => {
-        global.insights = {
-            chrome: {
-                isChrome2: true
-            }
-        };
-    });
-    test('add correct class', () => {
-        const result = chromeRenderLoader.bind({
-            options: {
-                appName: 'someName'
-            }
-        })('something');
-        expect(result.includes(`document.getElementById('root').classList.add('someName')`)).toBe(true);
-    });
+  beforeAll(() => {
+    global.insights = {
+      chrome: {
+        isChrome2: true,
+      },
+    };
+  });
+  test('add correct class', () => {
+    const result = chromeRenderLoader.bind({
+      options: {
+        appName: 'someName',
+      },
+    })('something');
+    expect(result.includes(`document.getElementById('root').classList.add('someName')`)).toBe(true);
+  });
 
-    test('calculate isChrome2 to be true', () => {
-        const result = chromeRenderLoader.bind({
-            options: {
-                appName: 'someName'
-            }
-        })('something');
-        expect(eval(result.match(/\((!.*(?=;))/)[0])).toBe(true);
-    });
+  test('calculate isChrome2 to be true', () => {
+    const result = chromeRenderLoader.bind({
+      options: {
+        appName: 'someName',
+      },
+    })('something');
+    expect(eval(result.match(/\((!.*(?=;))/)[0])).toBe(true);
+  });
 
-    test('calculate isChrome2 to be false', () => {
-        const result = chromeRenderLoader.bind({
-            options: {
-                appName: 'someName',
-                skipChrome2: true
-            }
-        })('something');
-        expect(eval(result.match(/\((!.*(?=;))/)[0])).toBe(false);
-    });
+  test('calculate isChrome2 to be false', () => {
+    const result = chromeRenderLoader.bind({
+      options: {
+        appName: 'someName',
+        skipChrome2: true,
+      },
+    })('something');
+    expect(eval(result.match(/\((!.*(?=;))/)[0])).toBe(false);
+  });
 });

package/chunk-mapper.js

@@ -1,39 +1,42 @@
 class ChunkMapper {
-    constructor(options) {
-        this.config = {};
-        this.options = options || {};
-    }
+  constructor(options) {
+    this.config = {};
+    this.options = options || {};
+  }
 
-    apply(compiler) {
-        compiler.hooks.emit.tap('ChunkMapper', (compilation) => {
-            const prefix = this.options.prefix || (RegExp('^/.*/$').test(compiler.options.output.publicPath) ? compiler.options.output.publicPath : '/');
-            compilation.chunks.forEach(({ name, files, runtime }) => {
-                const modules = Array.isArray(this.options.modules) ? this.options.modules : [ this.options.modules ];
-                if (modules.find((oneEntry) => RegExp(`${oneEntry}$`).test(runtime))) {
-                    this.config[runtime] = {
-                        ...(this.config[runtime] || {}),
-                        ...(name === runtime
-                            ? {
-                                entry: Array.from(files).map(item => `${prefix}${item}`).filter((file, _index, array) => {
-                                    if (array.find(item => !RegExp('\\.hot-update\\.js$').test(item))) {
-                                        return !RegExp('\\.hot-update\\.js$').test(file);
-                                    }
+  apply(compiler) {
+    compiler.hooks.emit.tap('ChunkMapper', (compilation) => {
+      const prefix = this.options.prefix || (RegExp('^/.*/$').test(compiler.options.output.publicPath) ? compiler.options.output.publicPath : '/');
+      compilation.chunks.forEach(({ name, files, runtime }) => {
+        const modules = Array.isArray(this.options.modules) ? this.options.modules : [this.options.modules];
+        if (modules.find((oneEntry) => RegExp(`${oneEntry}$`).test(runtime))) {
+          this.config[runtime] = {
+            ...(this.config[runtime] || {}),
+            ...(name === runtime
+              ? {
+                  entry: Array.from(files)
+                    .map((item) => `${prefix}${item}`)
+                    .filter((file, _index, array) => {
+                      if (array.find((item) => !RegExp('\\.hot-update\\.js$').test(item))) {
+                        return !RegExp('\\.hot-update\\.js$').test(file);
+                      }
 
-                                    return true;
-                                })
-                            } : {
-                                modules: [ ...(this.config[runtime].modules || []), ...Array.from(files).map((item) => `${prefix}${item}`) ]
-                            })
-                    };
+                      return true;
+                    }),
                 }
-            });
+              : {
+                  modules: [...(this.config[runtime].modules || []), ...Array.from(files).map((item) => `${prefix}${item}`)],
+                }),
+          };
+        }
+      });
 
-            compilation.assets['fed-mods.json'] = {
-                source: () => JSON.stringify(this.config, null, 4),
-                size: () => JSON.stringify(this.config, null, 4).length
-            };
-        });
-    }
+      compilation.assets['fed-mods.json'] = {
+        source: () => JSON.stringify(this.config, null, 4),
+        size: () => JSON.stringify(this.config, null, 4).length,
+      };
+    });
+  }
 }
 
 module.exports = ChunkMapper;

package/cookieTransform.js

@@ -3,51 +3,51 @@
 const jws = require('jws');
 
 const defaultEntitlements = {
-    insights: { is_entitled: true },
-    smart_management: { is_entitled: true },
-    openshift: { is_entitled: true },
-    hybrid: { is_entitled: true },
-    migrations: { is_entitled: true },
-    ansible: { is_entitled: true },
-    cost_management: { is_entitled: true }
+  insights: { is_entitled: true },
+  smart_management: { is_entitled: true },
+  openshift: { is_entitled: true },
+  hybrid: { is_entitled: true },
+  migrations: { is_entitled: true },
+  ansible: { is_entitled: true },
+  cost_management: { is_entitled: true },
 };
 
 function cookieTransform(proxyReq, req, _res, { entitlements = defaultEntitlements, user, internal, identity: customIdentity }) {
-    const cookie = req.headers.cookie;
-    const match = cookie && cookie.match(/cs_jwt=([^;]+)/);
-    if (match) {
-        const cs_jwt = match[1];
-        const { payload } = jws.decode(cs_jwt);
+  const cookie = req.headers.cookie;
+  const match = cookie && cookie.match(/cs_jwt=([^;]+)/);
+  if (match) {
+    const cs_jwt = match[1];
+    const { payload } = jws.decode(cs_jwt);
 
-        const identity = {
-            entitlements,
-            identity: {
-                type: 'User',
-                auth_type: 'basic-auth',
-                account_number: payload.account_number + '',
-                ...customIdentity,
-                user: {
-                    username: payload.username,
-                    email: payload.email,
-                    first_name: payload.first_name,
-                    last_name: payload.last_name,
-                    is_active: true,
-                    is_org_admin: payload.is_org_admin,
-                    is_internal: payload.is_internal,
-                    locale: 'en-US',
-                    user_id: payload.account_id + '',
-                    ...user
-                },
-                internal: {
-                    org_id: payload.org_id,
-                    auth_time: payload.auth_time,
-                    ...internal
-                }
-            }
-        };
-        const identityB64 = Buffer.from(JSON.stringify(identity), 'utf8').toString('base64');
-        proxyReq.setHeader('x-rh-identity', identityB64);
-    }
+    const identity = {
+      entitlements,
+      identity: {
+        type: 'User',
+        auth_type: 'basic-auth',
+        account_number: payload.account_number + '',
+        ...customIdentity,
+        user: {
+          username: payload.username,
+          email: payload.email,
+          first_name: payload.first_name,
+          last_name: payload.last_name,
+          is_active: true,
+          is_org_admin: payload.is_org_admin,
+          is_internal: payload.is_internal,
+          locale: 'en-US',
+          user_id: payload.account_id + '',
+          ...user,
+        },
+        internal: {
+          org_id: payload.org_id,
+          auth_time: payload.auth_time,
+          ...internal,
+        },
+      },
+    };
+    const identityB64 = Buffer.from(JSON.stringify(identity), 'utf8').toString('base64');
+    proxyReq.setHeader('x-rh-identity', identityB64);
+  }
 }
 
 module.exports = cookieTransform;

package/extension-mapper.js

@@ -1,77 +1,77 @@
 const webpack = require('webpack');
 
 class ExtensionsMapper {
-    constructor(plugin, options) {
-        if (!plugin) {
-            throw new Error('Missing plugin config!');
-        }
-
-        this.plugin = plugin;
-        this.options = {
-            remoteEntryCallback: 'window.loadPluginEntry',
-            remoteEntryFile: 'plugin-entry.js',
-            pluginManifestFile: 'plugin-manifest.json',
-            ...options
-        };
+  constructor(plugin, options) {
+    if (!plugin) {
+      throw new Error('Missing plugin config!');
     }
 
-    apply(compiler) {
-        compiler.hooks.thisCompilation.tap(ExtensionsMapper.name, (compilation) => {
-            // Generate extensions manifest
-            compilation.hooks.processAssets.tap(
-                {
-                    name: ExtensionsMapper.name,
-                    stage: webpack.Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL
-                },
-                () => {
-                    compilation.emitAsset(
-                        this.options.pluginManifestFile,
-                        new webpack.sources.RawSource(
-                            Buffer.from(JSON.stringify({
-                                version: '0.0.0',
-                                description: '',
-                                displayName: '',
-                                dependencies: {},
-                                disableStaticPlugins: {},
-                                ...this.plugin
-                            }, null, 2))
-                        )
-                    );
-                }
-            );
+    this.plugin = plugin;
+    this.options = {
+      remoteEntryCallback: 'window.loadPluginEntry',
+      remoteEntryFile: 'plugin-entry.js',
+      pluginManifestFile: 'plugin-manifest.json',
+      ...options,
+    };
+  }
+
+  apply(compiler) {
+    compiler.hooks.thisCompilation.tap(ExtensionsMapper.name, (compilation) => {
+      // Generate extensions manifest
+      compilation.hooks.processAssets.tap(
+        {
+          name: ExtensionsMapper.name,
+          stage: webpack.Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL,
+        },
+        () => {
+          compilation.emitAsset(
+            this.options.pluginManifestFile,
+            new webpack.sources.RawSource(
+              Buffer.from(
+                JSON.stringify(
+                  {
+                    version: '0.0.0',
+                    description: '',
+                    displayName: '',
+                    dependencies: {},
+                    disableStaticPlugins: {},
+                    ...this.plugin,
+                  },
+                  null,
+                  2
+                )
+              )
+            )
+          );
+        }
+      );
 
-            // Update plugin-entry.js file
-            compilation.hooks.processAssets.tap(
-                {
-                    name: ExtensionsMapper.name,
-                    stage: webpack.Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
-                },
-                () => {
-                    compilation.updateAsset(this.options.remoteEntryFile, (source) => {
-                        const newSource = new webpack.sources.ReplaceSource(source);
+      // Update plugin-entry.js file
+      compilation.hooks.processAssets.tap(
+        {
+          name: ExtensionsMapper.name,
+          stage: webpack.Compilation.PROCESS_ASSETS_STAGE_ADDITIONS,
+        },
+        () => {
+          compilation.updateAsset(this.options.remoteEntryFile, (source) => {
+            const newSource = new webpack.sources.ReplaceSource(source);
 
-                        const fromIndex = source
-                        .source()
-                        .toString()
-                        .indexOf(`${this.options.remoteEntryCallback}(`);
+            const fromIndex = source.source().toString().indexOf(`${this.options.remoteEntryCallback}(`);
 
-                        if (fromIndex < 0) {
-                            const error = new webpack.WebpackError(`Missing call to ${this.options.remoteEntryCallback}`);
-                            error.file = this.options.remoteEntryFile;
-                            compilation.errors.push(error);
-                        } else {
-                            newSource.insert(
-                                fromIndex + this.options.remoteEntryCallback.length + 1,
-                                `'${this.plugin.name}@${this.plugin.version}', `
-                            );
-                        }
+            if (fromIndex < 0) {
+              const error = new webpack.WebpackError(`Missing call to ${this.options.remoteEntryCallback}`);
+              error.file = this.options.remoteEntryFile;
+              compilation.errors.push(error);
+            } else {
+              newSource.insert(fromIndex + this.options.remoteEntryCallback.length + 1, `'${this.plugin.name}@${this.plugin.version}', `);
+            }
 
-                        return newSource;
-                    });
-                }
-            );
-        });
-    }
+            return newSource;
+          });
+        }
+      );
+    });
+  }
 }
 
 module.exports = ExtensionsMapper;

package/extensions-plugin.js

@@ -3,52 +3,52 @@ const fedModule = require('./federated-modules');
 const ExtensionsMapper = require('./extension-mapper');
 
 class ExtensionsPlugin {
-    constructor(plugin, fedMod, options) {
-        if (!plugin) {
-            throw new Error('Missing plugin config!');
-        }
-
-        this.plugin = plugin;
-        this.fedMod = {
-            moduleName: 'plugin-entry',
-            libName: 'window.loadPluginEntry',
-            useFileHash: false,
-            libType: 'jsonp',
-            ...fedMod
-        };
-        this.options = {
-            remoteEntryCallback: 'window.loadPluginEntry',
-            remoteEntryFile: `${this.fedMod.moduleName}.js`,
-            pluginManifestFile: 'plugin-manifest.json',
-            ...options
-        };
+  constructor(plugin, fedMod, options) {
+    if (!plugin) {
+      throw new Error('Missing plugin config!');
     }
 
-    apply(compiler) {
-        const root = this.fedMod.root || compiler.context;
-        const { insights, version, description } = require(resolve(root, './package.json')) || {};
+    this.plugin = plugin;
+    this.fedMod = {
+      moduleName: 'plugin-entry',
+      libName: 'window.loadPluginEntry',
+      useFileHash: false,
+      libType: 'jsonp',
+      ...fedMod,
+    };
+    this.options = {
+      remoteEntryCallback: 'window.loadPluginEntry',
+      remoteEntryFile: `${this.fedMod.moduleName}.js`,
+      pluginManifestFile: 'plugin-manifest.json',
+      ...options,
+    };
+  }
 
-        // create federation module
-        fedModule({
-            ...this.fedMod,
-            root
-        }).apply(compiler);
+  apply(compiler) {
+    const root = this.fedMod.root || compiler.context;
+    const { insights, version, description } = require(resolve(root, './package.json')) || {};
 
-        // generate plugin manifest and update plugin-entry file
-        new ExtensionsMapper(
-            {
-                ...this.plugin,
-                name: this.plugin.name || (insights && insights.appname),
-                version: this.plugin.version || version || '0.0.0',
-                displayName: this.plugin.displayName || '',
-                description: this.plugin.description || description || '',
-                dependencies: { ...this.plugin.dependencies || {} },
-                disableStaticPlugins: [ ...this.plugin.disableStaticPlugins || [] ],
-                extensions: [ ...this.plugin.extensions || [] ]
-            },
-            this.options
-        ).apply(compiler);
-    }
+    // create federation module
+    fedModule({
+      ...this.fedMod,
+      root,
+    }).apply(compiler);
+
+    // generate plugin manifest and update plugin-entry file
+    new ExtensionsMapper(
+      {
+        ...this.plugin,
+        name: this.plugin.name || (insights && insights.appname),
+        version: this.plugin.version || version || '0.0.0',
+        displayName: this.plugin.displayName || '',
+        description: this.plugin.description || description || '',
+        dependencies: { ...(this.plugin.dependencies || {}) },
+        disableStaticPlugins: [...(this.plugin.disableStaticPlugins || [])],
+        extensions: [...(this.plugin.extensions || [])],
+      },
+      this.options
+    ).apply(compiler);
+  }
 }
 
 module.exports = ExtensionsPlugin;

package/federated-modules.js

@@ -4,77 +4,64 @@ const { ModuleFederationPlugin } = require('webpack').container;
 const jsVarName = require('./jsVarName');
 
 const include = {
-    '@patternfly/react-core': {},
-    '@patternfly/react-table': {},
-    '@patternfly/react-tokens': {},
-    '@patternfly/react-icons': {},
-    '@patternfly/quickstarts': { singleton: true },
-    '@redhat-cloud-services/frontend-components': {},
-    '@redhat-cloud-services/frontend-components-utilities': {},
-    '@redhat-cloud-services/frontend-components-notifications': {},
-    axios: {},
-    lodash: {},
-    'redux-promise-middleware': {},
-    react: { singleton: true },
-    'react-dom': { singleton: true },
-    'react-router-dom': {}
+  '@patternfly/react-core': {},
+  '@patternfly/react-table': {},
+  '@patternfly/react-tokens': {},
+  '@patternfly/react-icons': {},
+  '@patternfly/quickstarts': { singleton: true },
+  '@redhat-cloud-services/frontend-components': {},
+  '@redhat-cloud-services/frontend-components-utilities': {},
+  '@redhat-cloud-services/frontend-components-notifications': {},
+  axios: {},
+  lodash: {},
+  'redux-promise-middleware': {},
+  react: { singleton: true },
+  'react-dom': { singleton: true },
+  'react-router-dom': {},
 };
 
-module.exports = ({
-    root,
-    exposes,
-    shared = [],
-    debug,
-    moduleName,
-    useFileHash = true,
-    libType = 'var',
-    libName,
-    exclude = []
-}) => {
-    const { dependencies, insights } = require(resolve(root, './package.json')) || {};
-    const appName = moduleName || (insights && jsVarName(insights.appname));
+module.exports = ({ root, exposes, shared = [], debug, moduleName, useFileHash = true, libType = 'var', libName, exclude = [] }) => {
+  const { dependencies, insights } = require(resolve(root, './package.json')) || {};
+  const appName = moduleName || (insights && jsVarName(insights.appname));
 
-    const sharedDeps = Object.entries(include)
-    .filter(([ key ]) => dependencies[key] && !exclude.includes(key))
-    .map(([ key, val ]) => ({
-        [key]: {
-            requiredVersion: dependencies[key],
-            ...val
-        }
+  const sharedDeps = Object.entries(include)
+    .filter(([key]) => dependencies[key] && !exclude.includes(key))
+    .map(([key, val]) => ({
+      [key]: {
+        requiredVersion: dependencies[key],
+        ...val,
+      },
     }));
 
-    /**
-     * Add scalprum and force it as singletong.
-     * It is required to share the context via `useChrome`.
-     * No application should be installing/interacting with scalprum directly.
-     */
-    if (dependencies['@redhat-cloud-services/frontend-components']) {
-        sharedDeps.push({ '@scalprum/react-core': { requiredVersion: '*', singleton: true } });
-    }
+  /**
+   * Add scalprum and force it as singletong.
+   * It is required to share the context via `useChrome`.
+   * No application should be installing/interacting with scalprum directly.
+   */
+  if (dependencies['@redhat-cloud-services/frontend-components']) {
+    sharedDeps.push({ '@scalprum/react-core': { requiredVersion: '*', singleton: true } });
+  }
 
-    if (debug) {
-        console.log('Using package at path: ', resolve(root, './package.json'));
-        console.log('Using appName: ', appName);
-        console.log(`Using ${exposes ? 'custom' : 'default'} exposes`);
-        console.log('Number of custom shared modules is: ', shared.length);
-        console.log('Number of default shared modules is: ', sharedDeps.length);
-        if (exclude.length > 0) {
-            console.log('Excluding default packages', exclude);
-        }
+  if (debug) {
+    console.log('Using package at path: ', resolve(root, './package.json'));
+    console.log('Using appName: ', appName);
+    console.log(`Using ${exposes ? 'custom' : 'default'} exposes`);
+    console.log('Number of custom shared modules is: ', shared.length);
+    console.log('Number of default shared modules is: ', sharedDeps.length);
+    if (exclude.length > 0) {
+      console.log('Excluding default packages', exclude);
     }
+  }
 
-    return new ModuleFederationPlugin({
-        name: appName,
-        filename: `${appName}${useFileHash ? `.${Date.now()}.[fullhash]` : ''}.js`,
-        library: { type: libType, name: libName || appName },
-        exposes: {
-            ...exposes || {
-                './RootApp': resolve(root, './src/AppEntry')
-            }
-        },
-        shared: [
-            ...sharedDeps,
-            ...shared
-        ]
-    });
+  return new ModuleFederationPlugin({
+    name: appName,
+    filename: `${appName}${useFileHash ? `.${Date.now()}.[fullhash]` : ''}.js`,
+    library: { type: libType, name: libName || appName },
+    exposes: {
+      ...(exposes || {
+        './RootApp': resolve(root, './src/AppEntry'),
+      }),
+    },
+    shared: [...sharedDeps, ...shared],
+  });
 };

package/jsVarName.js

@@ -1,11 +1,13 @@
 function jsVarName(s) {
-    return s
-    // Camel case dashes
-    .replace(/-(\w)/g, (_, match) => match.toUpperCase())
-    // Remove leading digits
-    .replace(/^[0-9]+/, '')
-    // Remove all non alphanumeric chars
-    .replace(/[^A-Za-z0-9]+/g, '');
+  return (
+    s
+      // Camel case dashes
+      .replace(/-(\w)/g, (_, match) => match.toUpperCase())
+      // Remove leading digits
+      .replace(/^[0-9]+/, '')
+      // Remove all non alphanumeric chars
+      .replace(/[^A-Za-z0-9]+/g, '')
+  );
 }
 
 module.exports = jsVarName;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@redhat-cloud-services/frontend-components-config-utilities",
-    "version": "1.5.9",
+    "version": "1.5.10",
     "description": "Utilities for shared config used in RedHat Cloud Services project.",
     "main": "index.js",
     "publishConfig": {

package/proxy.js

@@ -15,264 +15,270 @@ const { registerChrome } = require('./standalone/services/default/chrome');
 const defaultReposDir = path.join(__dirname, 'repos');
 
 module.exports = ({
-    env = 'ci-beta',
-    customProxy = [],
-    routes,
-    routesPath,
-    useProxy,
-    proxyURL = 'http://squid.corp.redhat.com:3128',
-    standalone,
-    port,
-    reposDir = defaultReposDir,
-    localChrome,
-    appUrl = [],
-    publicPath,
-    proxyVerbose,
-    useCloud = false,
-    target = '',
-    keycloakUri = '',
-    registry = [],
-    isChrome = false,
-    onBeforeSetupMiddleware = () => {}
+  env = 'ci-beta',
+  customProxy = [],
+  routes,
+  routesPath,
+  useProxy,
+  proxyURL = 'http://squid.corp.redhat.com:3128',
+  standalone,
+  port,
+  reposDir = defaultReposDir,
+  localChrome,
+  appUrl = [],
+  publicPath,
+  proxyVerbose,
+  useCloud = false,
+  target = '',
+  keycloakUri = '',
+  registry = [],
+  isChrome = false,
+  onBeforeSetupMiddleware = () => {},
 }) => {
-    const proxy = [];
-    const majorEnv = env.split('-')[0];
-    if (target === '') {
-        target += 'https://';
-        if (![ 'prod', 'stage' ].includes(majorEnv)) {
-            target += majorEnv + '.';
-        }
-
-        target += useCloud ? 'cloud' : 'console';
-        if (majorEnv === 'stage') {
-            target += '.stage';
-        }
-
-        target += '.redhat.com/';
+  const proxy = [];
+  const majorEnv = env.split('-')[0];
+  if (target === '') {
+    target += 'https://';
+    if (!['prod', 'stage'].includes(majorEnv)) {
+      target += majorEnv + '.';
     }
 
-    let agent;
-
-    if (env.startsWith('prod') || env.startsWith('stage')) {
-        // PROD and stage are deployed with Akamai which requires a corporate proxy
-        agent = new HttpsProxyAgent(proxyURL);
+    target += useCloud ? 'cloud' : 'console';
+    if (majorEnv === 'stage') {
+      target += '.stage';
     }
 
-    if (env.startsWith('stage')) {
-        // stage-stable / stage-beta branches don't exist in build repos
-        // Currently stage pulls from QA
-        env = env.replace('stage', 'qa');
-    }
-
-    if (!Array.isArray(appUrl)) {
-        appUrl = [ appUrl ];
-    }
+    target += '.redhat.com/';
+  }
+
+  let agent;
+
+  if (env.startsWith('prod') || env.startsWith('stage')) {
+    // PROD and stage are deployed with Akamai which requires a corporate proxy
+    agent = new HttpsProxyAgent(proxyURL);
+  }
+
+  if (env.startsWith('stage')) {
+    // stage-stable / stage-beta branches don't exist in build repos
+    // Currently stage pulls from QA
+    env = env.replace('stage', 'qa');
+  }
+
+  if (!Array.isArray(appUrl)) {
+    appUrl = [appUrl];
+  }
+
+  appUrl.push(publicPath);
+
+  if (routesPath) {
+    routes = require(routesPath);
+  }
+
+  if (routes) {
+    routes = routes.routes || routes;
+    console.log('Making proxy from SPANDX routes');
+    proxy.push(
+      ...Object.entries(routes || {}).map(([route, redirect]) => {
+        const currTarget = redirect.host || redirect;
+        delete redirect.host;
+        return {
+          context: (path) => path.includes(route),
+          target: currTarget === 'PORTAL_BACKEND_MARKER' ? target : currTarget,
+          secure: false,
+          changeOrigin: true,
+          autoRewrite: true,
+          ws: true,
+          onProxyReq: cookieTransform,
+          ...(currTarget === 'PORTAL_BACKEND_MARKER' && { router }),
+          ...(typeof redirect === 'object' ? redirect : {}),
+        };
+      })
+    );
+  }
+
+  if (customProxy) {
+    proxy.push(...customProxy);
+  }
+
+  let standaloneConfig;
+  if (standalone) {
+    standaloneConfig = getConfig(standalone, localChrome, env, port);
+    // Create network for services.
+    execSync(`docker network inspect ${NET} >/dev/null 2>&1 || docker network create ${NET}`);
+
+    // Clone repos and resolve functions
+    // If we manage the repos it's okay to overwrite the contents
+    const overwrite = reposDir === defaultReposDir;
+
+    // Resolve config functions for cross-service references
+    for (const [, proj] of Object.entries(standaloneConfig)) {
+      const { services, path, assets, register } = proj;
+      if (typeof register === 'function') {
+        registry.push(register);
+      }
+
+      if (isGitUrl(path)) {
+        // Add typical branch if not included
+        if (!path.includes('#')) {
+          proj.path = `${path}#${env}`;
+        }
 
-    appUrl.push(publicPath);
+        proj.path = checkoutRepo({ repo: proj.path, reposDir, overwrite });
+      }
 
-    if (routesPath) {
-        routes = require(routesPath);
-    }
+      Object.keys(assets || []).forEach((key) => {
+        if (isGitUrl(assets[key])) {
+          assets[key] = checkoutRepo({ repo: assets[key], reposDir, overwrite });
+        }
+      });
 
-    if (routes) {
-        routes = routes.routes || routes;
-        console.log('Making proxy from SPANDX routes');
-        proxy.push(
-            ...Object.entries(routes || {}).map(([ route, redirect ]) => {
-                const currTarget = redirect.host || redirect;
-                delete redirect.host;
-                return {
-                    context: (path) => path.includes(route),
-                    target: currTarget === 'PORTAL_BACKEND_MARKER' ? target : currTarget,
-                    secure: false,
-                    changeOrigin: true,
-                    autoRewrite: true,
-                    ws: true,
-                    onProxyReq: cookieTransform,
-                    ...(currTarget === 'PORTAL_BACKEND_MARKER' && { router }),
-                    ...typeof redirect === 'object' ? redirect : {}
-                };
-            })
-        );
+      // Resolve functions that depend on env, port, or assets
+      if (typeof services === 'function') {
+        proj.services = services({ env, port, assets });
+      }
     }
 
-    if (customProxy) {
-        proxy.push(...customProxy);
+    // Start standalone services.
+    for (const [projName, proj] of Object.entries(standaloneConfig)) {
+      const { services, path, assets, onProxyReq, keycloakUri, register, target, ...rest } = proj;
+      const serviceNames = [];
+      for (let [subServiceName, subService] of Object.entries(proj.services || {})) {
+        const name = [projName, subServiceName].join('_');
+        startService(standaloneConfig, name, subService);
+        serviceNames.push(name);
+        const port = getExposedPort(subService.args);
+        console.log('Container', name, 'listening', port ? 'on' : '', port || '');
+      }
+
+      process.on('SIGINT', () => serviceNames.forEach(stopService));
+
+      if (target) {
+        proxy.push({
+          secure: false,
+          changeOrigin: true,
+          onProxyReq: cookieTransform,
+          target,
+          ...rest,
+        });
+      }
     }
 
-    let standaloneConfig;
-    if (standalone) {
-        standaloneConfig = getConfig(standalone, localChrome, env, port);
-        // Create network for services.
-        execSync(`docker network inspect ${NET} >/dev/null 2>&1 || docker network create ${NET}`);
-
-        // Clone repos and resolve functions
-        // If we manage the repos it's okay to overwrite the contents
-        const overwrite = reposDir === defaultReposDir;
-
-        // Resolve config functions for cross-service references
-        for (const [ _projName, proj ] of Object.entries(standaloneConfig)) {
-            const { services, path, assets, register } = proj;
-            if (typeof register === 'function') {
-                registry.push(register);
-            }
-
-            if (isGitUrl(path)) {
-                // Add typical branch if not included
-                if (!path.includes('#')) {
-                    proj.path = `${path}#${env}`;
-                }
-
-                proj.path = checkoutRepo({ repo: proj.path, reposDir, overwrite });
-            }
-
-            Object.keys(assets || []).forEach(key => {
-                if (isGitUrl(assets[key])) {
-                    assets[key] = checkoutRepo({ repo: assets[key], reposDir, overwrite });
-                }
-            });
-
-            // Resolve functions that depend on env, port, or assets
-            if (typeof services === 'function') {
-                proj.services = services({ env, port, assets });
-            }
+    process.on('SIGINT', () => process.exit());
+  }
+
+  if (useProxy) {
+    // Catch-all
+    proxy.push({
+      secure: false,
+      changeOrigin: true,
+      autoRewrite: true,
+      context: (url) => {
+        const shouldProxy = !appUrl.find((u) => (typeof u === 'string' ? url.startsWith(u) : u.test(url)));
+        if (shouldProxy) {
+          if (proxyVerbose) {
+            console.log('proxy', url);
+          }
+
+          return true;
         }
 
-        // Start standalone services.
-        for (const [ projName, proj ] of Object.entries(standaloneConfig)) {
-            const { services, path, assets, onProxyReq, keycloakUri, register, target, ...rest } = proj;
-            const serviceNames = [];
-            for (let [ subServiceName, subService ] of Object.entries(proj.services || {})) {
-                const name = [ projName, subServiceName ].join('_');
-                startService(standaloneConfig, name, subService);
-                serviceNames.push(name);
-                const port = getExposedPort(subService.args);
-                console.log('Container', name, 'listening', port ? 'on' : '', port || '');
-            }
-
-            process.on('SIGINT', () => serviceNames.forEach(stopService));
-
-            if (target) {
-                proxy.push({
-                    secure: false,
-                    changeOrigin: true,
-                    onProxyReq: cookieTransform,
-                    target,
-                    ...rest
-                });
-            }
+        return false;
+      },
+      target,
+      ...(isChrome && {
+        bypass: (req) => {
+          /**
+           * Bypass any HTML requests if using chrome
+           * Serves as a historyApiFallback when refreshing on any other URL than '/'
+           */
+          if (!req.url.match(/\/api\//) && !req.url.match(/\./) && req.headers.accept.includes('text/html')) {
+            return '/';
+          }
+
+          return null;
+        },
+      }),
+      router: router(target, useCloud),
+      ...(agent && {
+        agent,
+        headers: {
+          // Staging Akamai CORS gives 403s for non-GET requests from non-origin hosts
+          Host: target.replace('https://', ''),
+          Origin: target,
+        },
+      }),
+    });
+  }
+
+  return {
+    ...(proxy.length > 0 && { proxy }),
+    onListening(server) {
+      if (useProxy || standaloneConfig) {
+        const host = useProxy ? `${majorEnv}.foo.redhat.com` : 'localhost';
+        const origin = `http${server.options.https ? 's' : ''}://${host}:${server.options.port}`;
+        console.log('App should run on:');
+
+        console.log('\u001b[34m'); // Use same webpack-dev-server blue
+        if (appUrl.length > 0) {
+          appUrl.slice(0, appUrl.length - 1).forEach((url) => console.log(`  - ${origin}${url}`));
+
+          console.log('\x1b[0m');
+          console.log('Static assets are available at:');
+          console.log('\u001b[34m'); // Use same webpack-dev-server blue
+          console.log(`  - ${origin}${appUrl[appUrl.length - 1]}`);
+        } else {
+          console.log(`  - ${origin}`);
         }
 
-        process.on('SIGINT', () => process.exit());
-    }
+        console.log('\u001b[0m');
+      }
+    },
+    onBeforeSetupMiddleware({ app, compiler, options }) {
+      app.enable('strict routing'); // trailing slashes are mean
+      /**
+       * Allow serving chrome assets
+       * This will allow running chrome as a host application
+       */
+      if (!isChrome) {
+        let chromePath = localChrome;
+        if (standaloneConfig) {
+          if (standaloneConfig.chrome) {
+            chromePath = resolvePath(reposDir, standaloneConfig.chrome.path);
+            keycloakUri = standaloneConfig.chrome.keycloakUri;
+          }
+        } else if (!localChrome && useProxy) {
+          if (typeof defaultServices.chrome === 'function') {
+            defaultServices.chrome = defaultServices.chrome({});
+          }
+
+          chromePath = checkoutRepo({
+            repo: `${defaultServices.chrome.path}#${env}`,
+            reposDir,
+            overwrite: true,
+          });
+        }
 
-    if (useProxy) {
-        // Catch-all
-        proxy.push({
-            secure: false,
-            changeOrigin: true,
-            autoRewrite: true,
-            context: url => {
-                const shouldProxy = !appUrl.find(u => typeof u === 'string' ? url.startsWith(u) : u.test(url));
-                if (shouldProxy) {
-                    if (proxyVerbose) {
-                        console.log('proxy', url);
-                    }
-
-                    return true;
-                }
-
-                return false;
-            },
-            target,
-            ...(isChrome && {
-                bypass: (req) => {
-                    /**
-                     * Bypass any HTML requests if using chrome
-                     * Serves as a historyApiFallback when refreshing on any other URL than '/'
-                     */
-                    if (!req.url.match(/\/api\//) && !req.url.match(/\./) && req.headers.accept.includes('text/html')) {
-                        return '/';
-                    }
-
-                    return null;
-                }
-            }),
-            router: router(target, useCloud),
-            ...(agent && {
-                agent,
-                headers: {
-                    // Staging Akamai CORS gives 403s for non-GET requests from non-origin hosts
-                    Host: target.replace('https://', ''),
-                    Origin: target
-                }
-            })
-        });
-    }
+        onBeforeSetupMiddleware({ chromePath });
 
-    return {
-        ...(proxy.length > 0 && { proxy }),
-        onListening(server) {
-            if (useProxy || standaloneConfig) {
-                const host = useProxy ? `${majorEnv}.foo.redhat.com` : 'localhost';
-                const origin = `http${server.options.https ? 's' : ''}://${host}:${server.options.port}`;
-                console.log('App should run on:');
-
-                console.log('\u001b[34m'); // Use same webpack-dev-server blue
-                if (appUrl.length > 0) {
-                    appUrl.forEach(url => console.log(`  - ${origin}${url}`));
-                } else {
-                    console.log(`  - ${origin}`);
-                }
-
-                console.log('\u001b[0m');
-            }
-        },
-        onBeforeSetupMiddleware({ app, compiler, options }) {
-            app.enable('strict routing'); // trailing slashes are mean
-            /**
-             * Allow serving chrome assets
-             * This will allow running chrome as a host application
-             */
-            if (!isChrome) {
-                let chromePath = localChrome;
-                if (standaloneConfig) {
-                    if (standaloneConfig.chrome) {
-                        chromePath = resolvePath(reposDir, standaloneConfig.chrome.path);
-                        keycloakUri = standaloneConfig.chrome.keycloakUri;
-                    }
-                } else if (!localChrome && useProxy) {
-                    if (typeof defaultServices.chrome === 'function') {
-                        defaultServices.chrome = defaultServices.chrome({});
-                    }
-
-                    chromePath = checkoutRepo({
-                        repo: `${defaultServices.chrome.path}#${env}`,
-                        reposDir,
-                        overwrite: true
-                    });
-                }
-
-                onBeforeSetupMiddleware({ chromePath });
-
-                if (chromePath) {
-                    registerChrome({
-                        app,
-                        chromePath,
-                        keycloakUri,
-                        https: Boolean(options.https),
-                        proxyVerbose
-                    });
-                }
-            }
-
-            registry.forEach(cb => cb({
-                app,
-                options,
-                compiler,
-                config: standaloneConfig
-            }));
+        if (chromePath) {
+          registerChrome({
+            app,
+            chromePath,
+            keycloakUri,
+            https: Boolean(options.https),
+            proxyVerbose,
+          });
         }
-    };
+      }
+
+      registry.forEach((cb) =>
+        cb({
+          app,
+          options,
+          compiler,
+          config: standaloneConfig,
+        })
+      );
+    },
+  };
 };
-

package/search-ignored-styles.js

@@ -7,11 +7,14 @@ const glob = require('glob');
  * @returns {Object}
  */
 const searchIgnoredStyles = (root) => {
-    const modulesPath = path.join(root, 'node_modules/@patternfly/react-styles');
-    return glob.sync(`${modulesPath}/**/*.css`).reduce((acc, curr) => ({
-        ...acc,
-        [curr]: false
-    }), {});
+  const modulesPath = path.join(root, 'node_modules/@patternfly/react-styles');
+  return glob.sync(`${modulesPath}/**/*.css`).reduce(
+    (acc, curr) => ({
+      ...acc,
+      [curr]: false,
+    }),
+    {}
+  );
 };
 
 module.exports = searchIgnoredStyles;

package/serve-federated.js

@@ -3,33 +3,33 @@ const fs = require('fs');
 const concurrently = require('concurrently');
 
 function federate(argv, cwd) {
-    let configPath = argv.config;
-    const WEBPACK_PATH = path.resolve(cwd, './node_modules/.bin/webpack');
-    const HTTP_SERVER_PATH = path.resolve(cwd, './node_modules/.bin/http-server');
-    if (typeof configPath !== 'string') {
-        console.error('Missing webpack config path');
-        process.exit(1);
-    }
+  let configPath = argv.config;
+  const WEBPACK_PATH = path.resolve(cwd, './node_modules/.bin/webpack');
+  const HTTP_SERVER_PATH = path.resolve(cwd, './node_modules/.bin/http-server');
+  if (typeof configPath !== 'string') {
+    console.error('Missing webpack config path');
+    process.exit(1);
+  }
 
-    configPath = path.join(cwd, configPath);
+  configPath = path.join(cwd, configPath);
 
-    try {
-        fs.statSync(configPath);
-        let config = require(configPath);
-        if (typeof config === 'function') {
-            config = config(process.env);
-        }
+  try {
+    fs.statSync(configPath);
+    let config = require(configPath);
+    if (typeof config === 'function') {
+      config = config(process.env);
+    }
 
-        const outputPath = config.output.path;
+    const outputPath = config.output.path;
 
-        concurrently([
-            `${WEBPACK_PATH} --config ${configPath} --watch --output-path ${path.join(outputPath, config.output.publicPath)}`,
-            `${HTTP_SERVER_PATH} ${outputPath} -p ${argv.port || 8003} -c-1`
-        ]);
-    } catch (error) {
-        console.error(error);
-        process.exit(1);
-    }
+    concurrently([
+      `${WEBPACK_PATH} --config ${configPath} --watch --output-path ${path.join(outputPath, config.output.publicPath)}`,
+      `${HTTP_SERVER_PATH} ${outputPath} -p ${argv.port || 8003} -c-1`,
+    ]);
+  } catch (error) {
+    console.error(error);
+    process.exit(1);
+  }
 }
 
 module.exports = federate;

package/serveLocalFile.js

@@ -1,18 +1,18 @@
 /* eslint-disable no-console */
 function serveLocalFile(url, path, target = 'https://ci.cloud.redhat.com') {
-    console.warn('\x1b[33mserveLocalFile is deprecated in favor of hooking into webpack-dev-server\'s express app.');
-    console.warn('See https://github.com/RedHatInsights/frontend-components/blob/master/packages/config/README.md#standalone');
-    return {
-        context: (path) => path.includes(url),
-        target,
-        secure: false,
-        changeOrigin: true,
-        autoRewrite: true,
-        selfHandleResponse: true,
-        onProxyReq: (_pr, _req, res) => {
-            res.sendFile(path);
-        }
-    };
+  console.warn("\x1b[33mserveLocalFile is deprecated in favor of hooking into webpack-dev-server's express app.");
+  console.warn('See https://github.com/RedHatInsights/frontend-components/blob/master/packages/config/README.md#standalone');
+  return {
+    context: (path) => path.includes(url),
+    target,
+    secure: false,
+    changeOrigin: true,
+    autoRewrite: true,
+    selfHandleResponse: true,
+    onProxyReq: (_pr, _req, res) => {
+      res.sendFile(path);
+    },
+  };
 }
 
 module.exports = serveLocalFile;