// 原子管理類，管理所有原子邏輯  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()