// 原子管理类，管理所有原子逻辑  class Atom {      /*    * 注入原子逻辑，以属性的方式管理    *   objArr： 原子逻辑数组    * */    setBasics(objArr) {      objArr.forEach(x => {        this[x.name] = x.assembly      })    }      /*    * 生产组装类所需要的原子    *   param    *     useBasics：组装类，所需要继承的原子    *       支持type： String - 指定一个、Array - 指定多个、无（undefined）- 所有    *    *   return    *     output：生产出的原子逻辑    * */    machiningBasics(useBasics) {      let output = {}      if (useBasics) {        if (Array.isArray(useBasics)) {          useBasics.forEach(x => {            Object.assign(output, this[x])          })        } else {          Object.assign(output, this[useBasics])        }      } else {        Object.keys(this).forEach(x => {          Object.assign(output, this[x])        })      }      return output    }  }    export default Atom

// 因ES6不支持私有属性，所以将私有属性放到外层    /*  * 生产组装对象，并注入指定作用域  *   param -  *  *   return  *     Temporary：组装对象  *  * */  function makeObject() {    function Temporary(assembly) {      for (let key in assembly) {        this[key] = assembly[key].bind(this)      }    }      return Temporary  }    /*  * 组装中是否透传原子方法  *   param  *     Temporary：组装对象  *     config： 组装的配置  *  *   return  *     output：输出最终逻辑  * */  function isThrough(Temporary, config) {    // 根据配置，实例化对象    let temp = new Temporary(config.assembly)    let output = {}    for (let key in temp) {      // 是否开启配置      if (config.through  === false) {        // 是否是自身属性        if (temp.hasOwnProperty(key)) {          output[key] = temp[key]        }      } else {        output[key] = temp[key]      }    }    return output  }    // 组装类，管理组装和输出。  class Package {      /*    * 注入组装配置    *   param    *     config：组装配置    *     prototype：组装所依赖的原子属性    *    *   return  生产完成的对象    * */    setPackage(config, prototype) {      let temp = makeObject(config)      temp.prototype = prototype      return isThrough(temp, config)    }    }    export default Package

import Atom from './atom/index'  import Package from './package/index'    // 实例化原子和组装类  const _atom = new Atom()  const _package = new Package()    // 生产原子缓存  let _globalCache = {}    /*  * 对外暴露，注入配置依赖，生产组装  *   param  *     param： 配置参数  * */  export const injection = function (param) {    _atom.setBasics(param.atom)      param.package.forEach(x => {      let prototype = _atom.machiningBasics(x.extends)      // 缓存组装      _globalCache[x.name] = _package.setPackage(x, prototype)    })  }    /*  * 对外暴露，获取生产完成的组装对象  *   param  *     param：获取的目标  *       type：String - 指定一个、Array - 指定多个、 无（undefined） - 全部  *  *   return  *     output：生产结束的对象  * */  export const getMateriel = function (param) {    let output = {}    if (param) {      if (Array.isArray(param)) {        return param.forEach(x => {          output[x] = _globalCache[x]        })      } else {        output = _globalCache[param]      }    } else {      output = _globalCache    }    return output  }

/*  *  injection方法注入对象的格式  *   atom：     所有的原子逻辑  *   package：  组装原子的逻辑  */  {    atom: ['原子逻辑1', '原子逻辑2'],    package: ['组装逻辑1', '组装逻辑2']  }

/*  *   该格式为原子逻辑的标准格式  *     name：       原子类的名称  *     assembly：   原子的方法存放的对象  */  export default {    name: '原子的名称',    assembly: {      // 原子逻辑所对外提供的方法      sendRequest() {        // do something      }    }  }

/*  *   该格式为组装逻辑的标准格式  *     name：       组装类的名称  *     extends：    组装类需要继承的原子  *     through：    是否透传原子类内部的信息  *     assembly：   原子的方法存放的对象  */  export default {    name: '组装类名称',    extends: '继承原子',      // 支持字符串（单原子）、无（默认继承所有原子）、数组（指定多个原子）    assembly: {      // 组装逻辑对外产出的方法，可直接this.来调用继承原子的方法      getAtom1Promise() {        // do something...      }    }  }

export default {    name: 'atom1',    assembly: {      sendRequest() {        return new Promise((res, rej) => {          setTimeout(function () {            res([1, 2, 3])          }, 3000)        })      }    }  }

export default {    name: 'atom2',    assembly: {      judgeArray(data) {        return Array.isArray(data)      }    }  }

export default {    name: 'package1',    extends: 'atom1',    assembly: {      getAtom1Promise() {        this.sendRequest()          .then(x => {            console.warn('使用成功', x)          })      }    }  }

export default {    name: 'package2',    through: false,    assembly: {      packageLogin() {        this.sendRequest()          .then(x => {            console.warn('判断是否是数组：', this.judgeArray(x))          })      }    }  }

import {injection, getMateriel} from '@fines/factory-js'    import atom1 from './atom/atom1'  import atom2 from './atom/atom2'  import package1 from './package/package1'  import package2 from './package/package2'    injection({    atom: [atom1, atom2],    package: [package1, package2]  })    console.warn('组装成功：', getMateriel())    // 测试package1方法  getMateriel('package1').getAtom1Promise()    // 测试package2方法  getMateriel('package2').packageLogin()