All files / ima/polyfill imaLoader.js

10.45% Statements 7/67
9.38% Branches 3/32
15.38% Functions 2/13
10.45% Lines 7/67
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 17131x   31x     31x     31x 31x   31x     6x                                                                                                                                                                                                                                                                                                                        
(function() {
  var root;
  Iif (typeof window !== 'undefined' && window !== null) {
    root = window;
  } else {
    root = global;
  }
 
  root.$IMA = root.$IMA || {};
  var modules = {};
 
  root.$IMA.Loader = {
    modules: modules,
    register: function(moduleName, dependencies, moduleFactory) {
      this.modules[moduleName] = {
        dependencies: dependencies,
        dependencyOf: [],
        factory: moduleFactory,
        instance: null
      };
    },
    replaceModule: function(moduleName, dependencies, moduleFactory) {
      var moduleDescriptor = this.modules[moduleName];
      if (!moduleDescriptor) {
        throw new Error(
          'You must register module "' + moduleName + '" at first.'
        );
      }
 
      Object.keys(this.modules).forEach(function(modulePath) {
        var module = root.$IMA.Loader.modules[modulePath];
 
        if (module.dependencies.indexOf(moduleName) > -1) {
          module.instance = null;
        }
      });
 
      moduleDescriptor.dependencies = dependencies;
      moduleDescriptor.factory = moduleFactory;
      moduleDescriptor.dependencyOf = [];
      moduleDescriptor.instance = null;
 
      return resolveModule(moduleName);
    },
    import: function(moduleName) {
      return Promise.resolve(this.importSync(moduleName));
    },
    importSync: function(moduleName) {
      if (!this.modules[moduleName]) {
        throw new Error(
          '$IMA.Loader.importSync: Module name ' +
            moduleName +
            ' is not registered. Update your build.js.'
        );
      }
 
      return resolveModule(moduleName);
    },
    initAllModules: function() {
      Object.keys(modules).forEach(function(moduleName) {
        resolveModule(moduleName);
      });
 
      return Promise.resolve();
    }
  };
 
  function resolveModule(moduleName, dependencyOf, parentDependencySetter) {
    if (!modules[moduleName]) {
      throw new Error(
        '$IMA.Loader.import: Module name ' +
          moduleName +
          (dependencyOf ? ' (dependency of ' + dependencyOf + ')' : '') +
          ' is not registered. Update your build.js.'
      );
    }
 
    var module = modules[moduleName];
    if (
      parentDependencySetter &&
      module.dependencyOf.indexOf(parentDependencySetter) === -1
    ) {
      // This is required for circular dependencies
      module.dependencyOf.push(parentDependencySetter);
    }
    if (module.instance) {
      return module.instance;
    }
 
    var moduleInstance = {};
    var moduleInitializer = module.factory(function _export(key, value) {
      moduleInstance[key] = value;
      // The exported values have been updated, notify the modules that
      // depend on this one - this is required for circular dependencies.
      module.dependencyOf.forEach(function(dependencySetter) {
        dependencySetter(moduleInstance);
      });
    });
    module.instance = moduleInstance; // allow lazy circular dependencies
 
    module.dependencies.forEach(function(dependencyName, index) {
      var resolvedName = resolveModuleName(moduleName, dependencyName);
      var setter = moduleInitializer.setters[index];
      var dependency = resolveModule(resolvedName, moduleName, setter);
      setter(dependency);
    });
 
    moduleInitializer.execute();
 
    return moduleInstance;
  }
 
  function resolveModuleName(currentModule, referencedModule) {
    var modulePath;
    if (referencedModule.substring(0, 2) === './') {
      if (currentModule.indexOf('/') > -1) {
        modulePath =
          currentModule.substring(0, currentModule.lastIndexOf('/')) +
          '/' +
          referencedModule.substring(2);
      } else {
        // the current module is in the application's root
        modulePath = referencedModule.substring(2);
      }
    } else if (referencedModule.substring(0, 3) === '../') {
      if (currentModule.indexOf('/') === -1) {
        throw new Error(
          'The ' +
            currentModule +
            ' module imports from the ' +
            'module ' +
            referencedModule +
            ' which may reside ' +
            'outside of the application directory'
        );
      }
 
      modulePath = currentModule.substring(0, currentModule.lastIndexOf('/'));
      modulePath =
        modulePath.substring(0, modulePath.lastIndexOf('/')) +
        '/' +
        referencedModule.substring(3);
    } else {
      return referencedModule;
    }
 
    modulePath = modulePath.replace(/\/\/+/g, '/');
    while (modulePath.indexOf('/./') > -1) {
      modulePath = modulePath.replace(/\/[.][/]/g, '/');
    }
    while (modulePath.indexOf('../') > -1) {
      if (modulePath.substring(0, 3) === '../') {
        throw new Error(
          'The ' +
            currentModule +
            ' module imports from the ' +
            'module ' +
            referencedModule +
            ' which may reside ' +
            'outside of the application directory'
        );
      }
      modulePath = modulePath.replace(/\/[^.][^/]*\/[.][.]\//g, '/');
      modulePath = modulePath.replace(/^[^.][^/]*\/[.][.]\//g, '');
    }
    modulePath = modulePath.replace(/^[.][/]/g, '');
 
    return modulePath;
  }
})();