apemanmodule/lib/apemanmodule.js

/**
 * Create a directory module index.
 * @function apemanmodule
 * @param {string} dirname - Directory path which contains modules.
 * @param {object} [options] - Optional settings.
 * @param {boolean} strict - Emit error if not found.
 * @param {string|string[]} pascal - Names to export as pascalcase
 * @param {object} vars - Variables in expression.
 * @returns {object} modules
 */

"use strict";

const argx = require('argx'),
    assert = require('assert'),
    path = require('path'),
    stringcase = require('stringcase'),
    print = require('./print'),
    _isModule = require('./_is_module'),
    _datasource = require('./_datasource');

/** @lends apemanmodule */
function apemanmodule(dirname, options) {
    let args = argx(arguments);
    options = args.pop('object') || {};
    dirname = args.shift('string');

    assert.ok(dirname, "[apemanmodule] dirname is required.");

    let pascal = options.pascal || [],
        vars = options.vars || {},
        strict = !!options.strict;

    let datasource = _datasource(dirname, {
        pascal: pascal,
        vars: vars
    });

    function modules(name) {

        let resolvedName = path.resolve(dirname, name);
        if (_isModule(resolvedName)) {
            return require(resolvedName);
        }

        let valid = modules.has(name);
        if (!valid) {
            let guess = modules.guess(name);
            if (strict) {
                let err = `Unknown module: "${name}".`;
                if (guess) {
                    err = `${err} ( Did you mean "${guess}"? )`;
                }
                throw new Error(err);
            } else {
                name = guess;
            }
        }
        let found = datasource[name];
        if (found && found.hasOwnProperty('default')) {
            // Fallback for es6 "export default" modules compiled by babel 6.x
            found = found.default;
        }
        if (typeof(found) === 'undefined') {
            console.warn(`[apemanmodule] Module not found with name: ${name}`);
        }
        return found;
    }

    modules.__proto__ = Object.assign(new Function(), {
        /**
         * Module data source.
         */
        datasource: datasource,
        /**
         * Check if has a module with name.
         * @param {string} name - Name of module.
         * @returns {*}
         */
        has(name) {
            return datasource.hasOwnProperty(name)
        },
        /**
         * Guess with name.
         * @param {string} name
         * @returns {*}
         */
        guess(name) {
            let converters = [stringcase.pascalcase, stringcase.camelcase];
            for (let convert of converters) {
                let convertedName = convert(name);
                let hit = modules.has(convertedName);
                if (hit) {
                    return convertedName;
                }
            }
            return null;
        },
        /**
         * Print modules
         * @param {string} [namespace] - Namespace to print.
         */
        print(namespace) {
            print(modules, namespace);
        }
    });

    Object.keys(datasource).forEach((key) => {
        Object.defineProperty(modules, key, {
            get: () => {
                return datasource[key];
            },
            configurable: true,
            enumerable: true
        })
    });

    return modules;
}

module.exports = apemanmodule;