joycon/index.js

const fs = require('fs')
const path = require('path')

/**
 * Read and return file data
 * @param {string} fp file path
 * @return {Promise<string>} file data
 */
const readFile = fp =>
  new Promise((resolve, reject) => {
    fs.readFile(fp, 'utf8', (err, data) => {
      if (err) return reject(err)
      resolve(data)
    })
  })

/**
 * Check if a file exists
 * @param {string} fp file path
 * @return {Promise<boolean>} whether it exists
 */
const pathExists = fp =>
  new Promise(resolve => {
    fs.access(fp, err => {
      resolve(!err)
    })
  })

/**
 * @typedef {(filepath: string) => any} Load
 * @typedef {{test: RegExp, load: Load}} Loader
 */

module.exports = class JoyCon {
  constructor(
    /** @type {{files?: string[], cwd?: string}} */
    { files, cwd = process.cwd() } = {}
  ) {
    this.options = {
      files,
      cwd
    }
    /** @type {Map<string, boolean>} */
    this.existsCache = new Map()
    /** @type {Set<Loader>} */
    this.loaders = new Set()
  }

  /**
   * Add a loader
   * @public
   * @param {Loader} loader
   */
  addLoader(loader) {
    this.loaders.add(loader)

    return this
  }

  /**
   * Resolve the files in working directory or parent directory
   * @private
   * @param {string[]} files Files to search
   * @param {string} cwd Working directory
   * @param {string} stopDir The directory to stop searching
   * @return {Promise<string|null>}
   */
  async recusivelyResolve(files, cwd, stopDir) {
    // Don't traverse above the module root
    if (cwd === stopDir || path.basename(cwd) === 'node_modules') {
      return null
    }

    for (const filename of files) {
      const file = path.join(cwd, filename)
      const exists = this.existsCache.has(file) ?
        this.existsCache.get(file) :
        await pathExists(file) // eslint-disable-line no-await-in-loop
      if (exists) {
        this.existsCache.set(file, true)
        return file
      }
    }

    // Continue in the parent directory
    return this.recusivelyResolve(files, path.dirname(cwd), stopDir)
  }

  /**
   * Search files and resolve the path
   * @param {string[]=} files Files to search
   * @param {string=} cwd Working directory
   * @param {string=} stopDir The directory to stop searching
   */
  resolve(files, cwd, stopDir) {
    files = files || this.options.files
    cwd = cwd || this.options.cwd
    stopDir = stopDir || path.parse(cwd).root

    if (!files || files.length === 0) {
      return Promise.reject(new Error('files must be an non-empty array!'))
    }

    return this.recusivelyResolve(files, cwd, stopDir)
  }

  /**
   * Search files and resolve the path and data
   * @param {string[]=} files Files to search
   * @param {string=} cwd Working directory
   * @param {string=} stopDir The directory to stop searching
   */
  async load(files, cwd, stopDir) {
    const filepath = await this.resolve(files, cwd, stopDir)
    if (filepath) {
      try {
        const load = this.findLoader(filepath)
        if (load) {
          return {
            path: filepath,
            data: await load(filepath)
          }
        }

        const extname = path.extname(filepath).slice(1)
        if (extname === 'js') {
          return {
            path: filepath,
            data: require(filepath)
          }
        }

        const data = await readFile(filepath)

        if (extname === 'json') {
          return {
            path: filepath,
            data: require('json5').parse(data)
          }
        }

        // Don't parse data
        // If it's neither .js nor .json
        // Leave this to user-land
        return {
          path: filepath,
          data
        }
      } catch (err) {
        if (err.code === 'MODULE_NOT_FOUND' || err.code === 'ENOENT') {
          this.existsCache.delete(filepath)
          return {}
        }

        throw err
      }
    }

    return {}
  }

  /**
   *  Find a loader for given path
   * @param {string} filepath file path
   * @return {Load|null}
   */
  findLoader(filepath) {
    for (const loader of this.loaders) {
      if (loader.test && loader.test.test(filepath)) {
        return loader.load
      }
    }

    return null
  }

  /** Clear cache used by this instance */
  clearCache() {
    this.existsCache.clear()

    return this
  }
}