codeceptjs 2.1.3 → 2.2.1

package/lib/command/definitions.js

@@ -9,23 +9,24 @@ const fs = require('fs');
 const path = require('path');
 
 const template = `
-type ICodeceptCallback = (i: CodeceptJS.{{I}}{{callbackParams}}) => void;
+type ICodeceptCallback = (i?: CodeceptJS.{{I}}, current?:any{{callbackParams}}) => void;
 
 declare class FeatureConfig {
-  retry(times:number): FeatureConfig
-  timeout(seconds:number): FeatureConfig
-  config(config:object): FeatureConfig
-  config(helperName:string, config:object): FeatureConfig
+  retry(times: number): FeatureConfig
+  timeout(seconds: number): FeatureConfig
+  config(config: object): FeatureConfig
+  config(helperName: string, config: object): FeatureConfig
 }
 
 declare class ScenarioConfig {
-  throws(err:any) : ScenarioConfig;
-  fails() : ScenarioConfig;
-  retry(times:number): ScenarioConfig
-  timeout(timeout:number): ScenarioConfig
-  inject(inject:object): ScenarioConfig
-  config(config:object): ScenarioConfig
-  config(helperName:string, config:object): ScenarioConfig
+  throws(err: any): ScenarioConfig;
+  fails(): ScenarioConfig;
+  retry(times: number): ScenarioConfig
+  timeout(timeout: number): ScenarioConfig
+  inject(inject: object): ScenarioConfig
+  config(config: object): ScenarioConfig
+  config(helperName: string, config: object): ScenarioConfig
+  injectDependencies(dependencies: { [key: string]: any }): ScenarioConfig
 }
 
 interface ILocator {
@@ -40,6 +41,134 @@ interface ILocator {
 
 type LocatorOrString = string | ILocator | Locator;
 
+declare class Container {
+  create(config: Object, opts: Object): void
+  plugins(name?: string): Object
+  support(name?: string): Object
+  helpers(name?: string): Object
+  translation(): Object
+  mocha(): Object
+  append(newContainer: Object): void
+  clear(newHelpers: Object, newSupport: Object, newPlugins: Object): void
+}
+
+declare class RecorderSession {
+  running: boolean
+    start(name: string): void
+    restore(name: string): void
+    catch(fn: CallableFunction): void
+}
+
+declare class Recorder {
+  retries: Object[]
+  start(): void
+  isRunning(): boolean
+  startUnlessRunning(): void
+  errHandler(fn: CallableFunction): void
+  reset(): void
+  session: RecorderSession
+  add(taskName, fn?: CallableFunction, force?: boolean, retry?: boolean): Promise<any>
+  retry(opts: Object): Promise<any>
+  catch(customErrFn: CallableFunction): Promise<any>
+  catchWithoutStop(customErrFn: CallableFunction ): Promise<any>
+  throw(err: Error): Promise<any>
+  saveFirstAsyncError(err: Error): void
+  getAsyncErr(): Promise<Error>
+  cleanAsyncErr(): void
+  stop():void
+  promise(): Promise<any>
+  scheduled(): string[]
+  toString(): string
+  add(hookName: string, fn: CallableFunction, force?: boolean): void
+  catch(customErrFn: CallableFunction)
+}
+
+declare class CodeceptJSEvent {
+  dispatcher: EventEmitter
+  test: {
+    started: string
+    before: string
+    after: string
+    passed: string
+    failed: string
+    finished: string
+  }
+  suite: {
+    before: string,
+    after: string,
+  }
+  hook: {
+    started: string,
+    passed: string,
+  }
+  step: {
+    before: string,
+    after: string,
+    started: string,
+    passed: string,
+    failed: string,
+    finished: string,
+  }
+  all: {
+    before: string,
+    after: string,
+    result: string,
+  }
+  multiple: {
+    before: string,
+    after: string,
+  }
+  emit(event: string, param: string)
+  cleanDispatcher(): void
+}
+
+declare class Output {
+  colors: any
+  styles: {
+    error: any,
+    success: any,
+    scenario: any,
+    basic: any,
+    debug: any,
+    log: any,
+  }
+
+  print(msg: string): void
+  stepShift: number
+  level(level: number): number
+  process(process: string): string
+  debug(msg: string): void
+  log(msg: string): void
+  error(msg: string): void
+  success(msg: string): void
+  plugin(name: string, msg: string): void
+  step(step: any): void
+  suite: {
+    started: Function
+  }
+  test: {
+    started(test: string): void
+    passed(test: string): void
+    failed(test: string): void
+    skipped(test: string): void
+  }
+  scenario: {
+    started(test: string): void
+    passed(test: string): void
+    failed(test: string): void
+  }
+  say(message: string, color?: string): void
+  result(passed: number, failed: number, skipped: number, duration: string): void
+}
+
+declare class Config {
+  create(newConfig: Object): Object
+  load(configFile: string): Config
+  get(key: string, val: any): any
+  append(additionalConfig: Object): Object
+  reset(): Object
+}
+
 declare class Helper {
   /** Abstract method to provide required config options */
   static _config(): any;
@@ -110,24 +239,43 @@ declare const Scenario: {
   only(title: string, callback: ICodeceptCallback): ScenarioConfig;
   only(title: string, opts: {}, callback: ICodeceptCallback): ScenarioConfig;
 }
+declare interface IScenario {
+  Scenario(title: string, callback: ICodeceptCallback): ScenarioConfig;
+  Scenario(title: string, opts: {}, callback: ICodeceptCallback): ScenarioConfig;
+}
 declare function xScenario(title: string, callback: ICodeceptCallback): ScenarioConfig;
 declare function xScenario(title: string, opts: {}, callback: ICodeceptCallback): ScenarioConfig;
-declare function Data(data: any): any;
-declare function xData(data: any): any;
+declare interface IData {
+  Scenario(title: string, callback: ICodeceptCallback): ScenarioConfig;
+  Scenario(title: string, opts: {}, callback: ICodeceptCallback): ScenarioConfig;
+  only: IScenario;
+}
+declare function Data(data: any): IData;
+declare function xData(data: any): IData;
 declare function Before(callback: ICodeceptCallback): void;
 declare function BeforeSuite(callback: ICodeceptCallback): void;
 declare function After(callback: ICodeceptCallback): void;
 declare function AfterSuite(callback: ICodeceptCallback): void;
 
+declare function inject(): {
+{{injectPageObjects}}
+};
 declare function locate(selector: LocatorOrString): Locator;
 declare function within(selector: LocatorOrString, callback: Function): Promise<any>;
-declare function session(selector: string, callback: Function): Promise<any>;
-declare function session(selector: string, config: any, callback: Function): Promise<any>;
+declare function session(selector: LocatorOrString, callback: Function): Promise<any>;
+declare function session(selector: LocatorOrString, config: any, callback: Function): Promise<any>;
 declare function pause(): void;
+declare function secret(secret: any): string;
 
 declare const codeceptjs: any;
 
 declare namespace CodeceptJS {
+  export const container: Container
+  export const recorder: Recorder
+  export const event: CodeceptJSEvent
+  export const output: Output
+  export const config: Config
+
   export interface {{I}} {
 {{methods}}
   }
@@ -135,10 +283,12 @@ declare namespace CodeceptJS {
 }
 
 declare module "codeceptjs" {
-    export = CodeceptJS;
+  export = CodeceptJS;
 }
 `;
 
+const injectSupportTemplate = '  {{name}}: CodeceptJS.{{name}}';
+
 const pageObjectTemplate = `
   export interface {{name}} {
 {{methods}}
@@ -151,6 +301,8 @@ module.exports = function (genPath, options) {
   const config = getConfig(configFile);
   if (!config) return;
 
+  const targetFolderPath = options.output && getTestRoot(options.output) || testsPath;
+
   const codecept = new Codecept(config, {});
   codecept.init(testsPath);
 
@@ -167,33 +319,34 @@ module.exports = function (genPath, options) {
 
   const supports = container.support(); // return all support objects
   const exportPageObjects = [];
+  const injectPageObjects = [];
   const callbackParams = [];
-  for (const name in supports) {
-    if (name === 'I') continue;
-    callbackParams.push(`${name}:CodeceptJS.${name}`);
+  // See #1795 and #1799, there's no obvious way to use for-in with Proxies
+  Reflect.ownKeys(supports).forEach((name) => {
+    if (name === 'I') {
+      injectPageObjects.push(injectSupportTemplate.replace(/{{name}}/g, String(name)));
+      return;
+    }
+    callbackParams.push(`${String(name)}?:CodeceptJS.${String(name)}`);
     const pageObject = supports[name];
     const pageMethods = addAllMethodsInObject(pageObject, {}, []);
     let pageObjectExport = pageObjectTemplate.replace('{{methods}}', pageMethods.join(''));
-    pageObjectExport = pageObjectExport.replace('{{name}}', name);
+    pageObjectExport = pageObjectExport.replace('{{name}}', String(name));
+    injectPageObjects.push(injectSupportTemplate.replace(/{{name}}/g, String(name)));
     exportPageObjects.push(pageObjectExport);
-  }
+  });
 
   let definitionsTemplate = template.replace('{{methods}}', methods.join(''));
   definitionsTemplate = definitionsTemplate.replace('{{exportPageObjects}}', exportPageObjects.join('\n'));
-  if (callbackParams.length > 0) {
-    definitionsTemplate = definitionsTemplate.replace('{{callbackParams}}', `, ${callbackParams.join(', ')}`);
-  } else {
-    definitionsTemplate = definitionsTemplate.replace('{{callbackParams}}', '');
-  }
+  definitionsTemplate = definitionsTemplate.replace('{{injectPageObjects}}', injectPageObjects.join('\n'));
+  definitionsTemplate = definitionsTemplate.replace('{{callbackParams}}', `, ${[...callbackParams, '...args: any'].join(', ')}`);
   if (translations) {
     definitionsTemplate = definitionsTemplate.replace(/\{\{I\}\}/g, translations.I);
   }
 
-  fs.writeFileSync(path.join(testsPath, 'steps.d.ts'), definitionsTemplate);
+  fs.writeFileSync(path.join(targetFolderPath, 'steps.d.ts'), definitionsTemplate);
   output.print('TypeScript Definitions provide autocompletion in Visual Studio Code and other IDEs');
   output.print('Definitions were generated in steps.d.ts');
-  output.print('Load them by adding at the top of a test file:');
-  output.print(output.colors.grey('\n/// <reference path="./steps.d.ts" />'));
 };
 
 function addAllMethodsInObject(supportObj, actions, methods, translations) {

package/lib/command/gherkin/snippets.js

@@ -8,6 +8,7 @@ const { Parser } = require('gherkin');
 const glob = require('glob');
 const fsPath = require('path');
 const fs = require('fs');
+const escapeStringRegexp = require('escape-string-regexp');
 
 const parser = new Parser();
 parser.stopAtFirstError = false;
@@ -30,13 +31,17 @@ module.exports = function (genPath, options) {
     output.error('No gherkin steps defined in config. Exiting');
     process.exit(1);
   }
-  if (!config.gherkin.features) {
+  if (!options.feature && !config.gherkin.features) {
     output.error('No gherkin features defined in config. Exiting');
     process.exit(1);
   }
+  if (options.path && !config.gherkin.steps.includes(options.path)) {
+    output.error(`You must include ${options.path} to the gherkin steps in your config file`);
+    process.exit(1);
+  }
 
   const files = [];
-  glob.sync(config.gherkin.features, { cwd: global.codecept_dir }).forEach((file) => {
+  glob.sync(options.feature || config.gherkin.features, { cwd: options.feature ? '.' : global.codecept_dir }).forEach((file) => {
     if (!fsPath.isAbsolute(file)) {
       file = fsPath.join(global.codecept_dir, file);
     }
@@ -58,11 +63,21 @@ module.exports = function (genPath, options) {
       try {
         matchStep(step.text);
       } catch (err) {
-        let stepLine = step.text
-          .replace(/\"(.*?)\"/g, '{string}')
-          .replace(/(\d+\.\d+)/, '{float}')
-          .replace(/ (\d+) /, ' {int} ');
-        stepLine = Object.assign(stepLine, { type: step.keyword.trim(), location: step.location });
+        let stepLine;
+        if (/[{}()/]/.test(step.text)) {
+          stepLine = escapeStringRegexp(step.text)
+            .replace(/\//g, '\\/')
+            .replace(/\"(.*?)\"/g, '"(.*?)"')
+            .replace(/(\d+\\\.\d+)/, '(\\d+\\.\\d+)')
+            .replace(/ (\d+) /, ' (\\d+) ');
+          stepLine = Object.assign(stepLine, { type: step.keyword.trim(), location: step.location, regexp: true });
+        } else {
+          stepLine = step.text
+            .replace(/\"(.*?)\"/g, '{string}')
+            .replace(/(\d+\.\d+)/, '{float}')
+            .replace(/ (\d+) /, ' {int} ');
+          stepLine = Object.assign(stepLine, { type: step.keyword.trim(), location: step.location, regexp: false });
+        }
         newSteps.push(stepLine);
       }
     }
@@ -81,7 +96,12 @@ module.exports = function (genPath, options) {
 
   files.forEach(file => parseFile(file));
 
-  let stepFile = config.gherkin.steps[0];
+  let stepFile = options.path || config.gherkin.steps[0];
+  if (!fs.existsSync(stepFile)) {
+    output.error('Please enter a valid step file path ', stepFile);
+    process.exit(1);
+  }
+
   if (!fsPath.isAbsolute(stepFile)) {
     stepFile = fsPath.join(global.codecept_dir, stepFile);
   }
@@ -90,7 +110,7 @@ module.exports = function (genPath, options) {
     .filter((value, index, self) => self.indexOf(value) === index)
     .map((step) => {
       return `
-${step.type}('${step}', () => {
+${step.type}(${step.regexp ? '/^' : "'"}${step}${step.regexp ? '$/' : "'"}, () => {
   // From "${step.file}" ${JSON.stringify(step.location)}
   throw new Error('Not implemented yet');
 });`;

package/lib/command/init.js

@@ -4,7 +4,8 @@ const fs = require('fs');
 const path = require('path');
 const { fileExists, beautify } = require('../utils');
 const inquirer = require('inquirer');
-const getTestRoot = require('./utils').getTestRoot;
+const { getTestRoot } = require('./utils');
+const generateDefinitions = require('./definitions');
 const isLocal = require('../utils').installedLocally();
 const mkdirp = require('mkdirp');
 const { inspect } = require('util');
@@ -18,7 +19,7 @@ const defaultConfig = {
   mocha: {},
 };
 
-const helpers = ['WebDriver', 'Protractor', 'Puppeteer', 'Nightmare', 'Appium'];
+const helpers = ['WebDriver', 'Puppeteer', 'TestCafe', 'Protractor', 'Nightmare', 'Appium'];
 const translations = Object.keys(require('../../translations'));
 
 const noTranslation = 'English (no localization)';
@@ -123,7 +124,7 @@ module.exports = function (initPath) {
     // append file mask to the end of tests
     if (!config.tests.match(/\*(.*?)$/)) {
       config.tests = `${config.tests.replace(/\/+$/, '')}/*_test.js`;
-      console.log(`Adding default test mask: ${config.tests}`);
+      console.print(`Adding default test mask: ${config.tests}`);
     }
 
     if (result.translation !== noTranslation) config.translation = result.translation;
@@ -158,28 +159,48 @@ module.exports = function (initPath) {
         }
         fs.writeFileSync(stepFile, defaultActor);
         config.include.I = result.steps_file;
-        success(`Steps file created at ${stepFile}`);
+        print(`Steps file created at ${stepFile}`);
       }
 
       fs.writeFileSync(configFile, beautify(`exports.config = ${inspect(config, false, 4, false)}`), 'utf-8');
-      success(`Config created at ${configFile}`);
+      print(`Config created at ${configFile}`);
 
       if (config.output) {
         if (!fileExists(config.output)) {
           mkdirp.sync(path.join(testsPath, config.output));
-          success(`Directory for temporary output files created at '${config.output}'`);
+          print(`Directory for temporary output files created at '${config.output}'`);
         } else {
           print(`Directory for temporary output files is already created at '${config.output}'`);
         }
       }
-      success('Almost done! Create your first test by executing `npx codeceptjs gt` (generate test) command');
+
+
+      const jsconfig = {
+        compilerOption: {
+          allowJs: true,
+        },
+      };
+      const jsconfigJson = beautify(JSON.stringify(jsconfig));
+      const jsconfigFile = path.join(testsPath, 'jsconfig.json');
+      if (fileExists(jsconfigFile)) {
+        print(`jsconfig.json has already exists at ${jsconfigFile}`);
+      } else {
+        fs.writeFileSync(jsconfigFile, jsconfigJson);
+        print(`Intellisense enabled in ${jsconfigFile}`);
+      }
+
+      generateDefinitions(testsPath, {});
+
+      print('');
+      success(' Almost done! Next step:');
+      success(' Create your first test by executing `npx codeceptjs gt` command ');
 
       if (packages) {
         print('\n--');
         if (isLocal) {
-          print(`Please install dependent packages locally: ${colors.bold(`npm install --save-dev ${packages.join(' ')}`)}`);
+          success(`Please install dependent packages locally: ${colors.bold(`npm install --save-dev ${packages.join(' ')}`)}`);
         } else {
-          print(`Please install dependent packages globally: [sudo] ${colors.bold(`npm install -g ${packages.join(' ')}`)}`);
+          success(`Please install dependent packages globally: [sudo] ${colors.bold(`npm install -g ${packages.join(' ')}`)}`);
         }
       }
     };
@@ -194,6 +215,7 @@ module.exports = function (initPath) {
         config.helpers[helperName][configName] = helperResult[key];
       });
 
+      print('');
       finish();
     });
   });

package/lib/command/run-multiple.js

@@ -3,10 +3,12 @@ const {
 } = require('./utils');
 const fork = require('child_process').fork;
 const path = require('path');
+const crypto = require('crypto');
 const runHook = require('../hooks');
 const event = require('../event');
 const collection = require('./run-multiple/collection');
 const clearString = require('../utils').clearString;
+const replaceValueDeep = require('../utils').replaceValueDeep;
 
 const runner = path.join(__dirname, '/../../bin/codecept');
 let config;
@@ -61,48 +63,52 @@ module.exports = function (selectedRuns, options) {
     fail('No runs provided. Use --all option to run all configured runs');
   }
 
-  const done = () => event.emit(event.multiple.before, null);
-  runHook(config.bootstrapAll, done, 'bootstrapAll');
+  const done = () => {
+    event.emit(event.multiple.before, null);
+    if (options.config) { // update paths to config path
+      if (config.tests) {
+        config.tests = path.resolve(testRoot, config.tests);
+      }
+      if (config.gherkin && config.gherkin.features) {
+        config.gherkin.features = path.resolve(testRoot, config.gherkin.features);
+      }
+    }
 
-  if (options.config) { // update paths to config path
-    config.tests = path.resolve(testRoot, config.tests);
-    if (config.gherkin && config.gherkin.features) {
-      config.gherkin.features = path.resolve(testRoot, config.gherkin.features);
+    if (options.features) {
+      config.tests = '';
     }
-  }
 
-  if (options.features) {
-    config.tests = '';
-  }
+    if (options.tests && config.gherkin) {
+      config.gherkin.features = '';
+    }
 
-  if (options.tests && config.gherkin) {
-    config.gherkin.features = '';
-  }
+    const childProcessesPromise = new Promise((resolve, reject) => {
+      processesDone = resolve;
+    });
 
-  const childProcessesPromise = new Promise((resolve, reject) => {
-    processesDone = resolve;
-  });
+    const runsToExecute = [];
+    collection.createRuns(selectedRuns, config).forEach((run) => {
+      const runName = run.getOriginalName() || run.getName();
+      const runConfig = run.getConfig();
+      runsToExecute.push(executeRun(runName, runConfig));
+    });
 
-  const runsToExecute = [];
-  collection.createRuns(selectedRuns, config).forEach((run) => {
-    const runName = run.getOriginalName() || run.getName();
-    const runConfig = run.getConfig();
-    runsToExecute.push(executeRun(runName, runConfig));
-  });
+    if (!runsToExecute.length) {
+      fail('Nothing scheduled for execution');
+    }
 
-  if (!runsToExecute.length) {
-    fail('Nothing scheduled for execution');
-  }
+    // Execute all forks
+    totalSubprocessCount = runsToExecute.length;
+    runsToExecute.forEach(runToExecute => runToExecute.call(this));
 
-  // Execute all forks
-  totalSubprocessCount = runsToExecute.length;
-  runsToExecute.forEach(runToExecute => runToExecute.call(this));
+    return childProcessesPromise.then(() => {
+      // fire hook
+      const done = () => event.emit(event.multiple.after, null);
+      runHook(config.teardownAll, done, 'teardownAll');
+    });
+  };
 
-  return childProcessesPromise.then(() => {
-    // fire hook
-    const done = () => event.emit(event.multiple.after, null);
-    runHook(config.teardownAll, done, 'teardownAll');
-  });
+  runHook(config.bootstrapAll, done, 'bootstrapAll');
 };
 
 function executeRun(runName, runConfig) {
@@ -114,23 +120,25 @@ function executeRun(runName, runConfig) {
   const browserName = browserConfig.browser;
 
   for (const key in browserConfig) {
-    overriddenConfig.helpers = replaceValue(overriddenConfig.helpers, key, browserConfig[key]);
+    overriddenConfig.helpers = replaceValueDeep(overriddenConfig.helpers, key, browserConfig[key]);
   }
 
   let outputDir = `${runName}_`;
   if (browserConfig.outputName) {
     outputDir += typeof browserConfig.outputName === 'function' ? browserConfig.outputName() : browserConfig.outputName;
   } else {
-    outputDir += JSON.stringify(browserConfig).replace(/[^\d\w]+/g, '_');
+    const hash = crypto.createHash('md5');
+    hash.update(JSON.stringify(browserConfig));
+    outputDir += hash.digest('hex');
   }
   outputDir += `_${runId}`;
 
   outputDir = clearString(outputDir);
 
   // tweaking default output directories and for mochawesome
-  overriddenConfig = replaceValue(overriddenConfig, 'output', path.join(config.output, outputDir));
-  overriddenConfig = replaceValue(overriddenConfig, 'reportDir', path.join(config.output, outputDir));
-  overriddenConfig = replaceValue(overriddenConfig, 'mochaFile', path.join(config.output, outputDir, `${browserName}_report.xml`));
+  overriddenConfig = replaceValueDeep(overriddenConfig, 'output', path.join(config.output, outputDir));
+  overriddenConfig = replaceValueDeep(overriddenConfig, 'reportDir', path.join(config.output, outputDir));
+  overriddenConfig = replaceValueDeep(overriddenConfig, 'mochaFile', path.join(config.output, outputDir, `${browserName}_report.xml`));
 
   // override tests configuration
   if (overriddenConfig.tests) {
@@ -178,24 +186,3 @@ function executeRun(runName, runConfig) {
       return onProcessEnd(1);
     });
 }
-
-
-/**
- * search key in object recursive and replace value in it
- */
-function replaceValue(obj, key, value) {
-  if (!obj) return;
-  if (obj instanceof Array) {
-    for (const i in obj) {
-      replaceValue(obj[i], key, value);
-    }
-  }
-  if (obj[key]) obj[key] = value;
-  if (typeof obj === 'object' && obj !== null) {
-    const children = Object.keys(obj);
-    for (let childIndex = 0; childIndex < children.length; childIndex++) {
-      replaceValue(obj[children[childIndex]], key, value);
-    }
-  }
-  return obj;
-}

package/lib/command/utils.js

@@ -11,7 +11,7 @@ module.exports.getConfig = function (configFile) {
   try {
     return require('../config').load(configFile);
   } catch (err) {
-    fail(err.message);
+    fail(err.stack);
   }
 };
 

package/lib/container.js

@@ -167,7 +167,7 @@ function createSupportObjects(config) {
     objects[name] = {}; // placeholders
   }
 
-  if (!objects.I) {
+  if (!config.I) {
     objects.I = require('./actor')();
 
     if (container.translation.I !== 'I') {
@@ -177,7 +177,7 @@ function createSupportObjects(config) {
 
   container.support = objects;
 
-  for (const name in config) {
+  function lazyLoad(name) {
     let newObj = getSupportObject(config, name);
     try {
       if (typeof newObj === 'function') {
@@ -188,8 +188,9 @@ function createSupportObjects(config) {
     } catch (err) {
       throw new Error(`Initialization failed for ${name}: ${newObj}\n${err.message}`);
     }
-    Object.assign(objects[name], newObj);
+    return newObj;
   }
+
   const asyncWrapper = function (f) {
     return function () {
       return f.apply(this, arguments).catch((e) => {
@@ -209,7 +210,32 @@ function createSupportObjects(config) {
     });
   });
 
-  return objects;
+  return new Proxy({}, {
+    has(target, key) {
+      return key in config;
+    },
+    ownKeys() {
+      return Reflect.ownKeys(config);
+    },
+    get(target, key) {
+      // configured but not in support object, yet: load the module
+      if (key in objects && !(key in target)) {
+        // load default I
+        if (key in objects && !(key in config)) {
+          return target[key] = objects[key];
+        }
+
+        // load new object
+        const object = lazyLoad(key);
+        // check that object is a real object and not an array
+        if (Object.prototype.toString.call(object) === '[object Object]') {
+          return target[key] = Object.assign(objects[key], object);
+        }
+        target[key] = object;
+      }
+      return target[key];
+    },
+  });
 }
 
 function createPlugins(config, options = {}) {