auto-exports
Version:
creates a module.exports map for all modules in a directory
168 lines (109 loc) • 3.23 kB
Markdown
# auto-exports
> creates a `module.exports` map for all modules in a directory
[![NPM][1]][2]
## TL;DR
here's the gist of it, in a one-liner:
###### index.js
```javascript
module.exports = require('auto-exports')();
```
## installation
```shell
npm i auto-exports -S
```
## usage
this module exports (no pun intended) a single function, which
synchronously transforms all modules in a directory (*except for
`index.js` and `index.node`!*) into a dictionary suited for `module.exports`.
the keys in this dictionary are camel-cased module names, and the values
hold the loaded modules.
this function accepts the modules directory path as the first argument,
a list of module names to exclude as the second, and a module interceptor
as the third. all arguments are optional.
if the directory path is omitted, it is auto-resolved to the path of the
requiring module (same as passing `__dirname`).
the module exclusions list is an array of modules names that will be
excluded from the resulted dictionary.
the module interceptor is a function that's called after each module has
been loaded. it receives two arguments: the module name, and the loaded
module, and may return the module after modifying it. useful if you want
to add a method to each module, or wrap all modules with the same type
of proxy, or to [insert your idea here].
## examples
let's assume we have a directory with two modules; `foo-foo.js`,
which exports an object, and `bar-bar.js`, which exports a function.
in that directory, we also have an additional `index.js` file, where we
call `autoExports()`.
#### just auto load all modules
###### index.js
```javascript
const autoExports = require('auto-exports');
module.exports = autoExports(__dirname);
```
###### result
```javascript
{
fooFoo: [Object],
barBar: [Function]
}
```
#### auto-magically load all modules!
###### index.js
```javascript
// ...
module.exports = autoExports(); // look, mummy, no args!
```
###### result
*same as before*
#### exclude some modules
###### index.js
```javascript
// ...
module.exports = autoExports(__dirname, ['foo-foo']);
```
###### result
```javascript
{
barBar: [Function]
}
```
#### modify each loaded module
###### index.js
```javascript
// ...
module.exports = autoExports(__dirname, (moduleName, module) => {
return new Proxy(module, {
get (target, key) {
return Reflect.get(target, key) || `${moduleName}'s got no ${key}`;
}
});
});
```
###### result
```javascript
{
fooFoo: [Proxy],
barBar: [Proxy]
}
```
#### exclude some modules and modify each loaded module
###### index.js
```javascript
// ...
module.exports = autoExports(__dirname, ['bar-bar'], (moduleName, module) => {
return Object.defineProperty(module, 'wat', { value: moduleName });
});
```
###### result
```javascript
{
fooFoo: [Object]
}
// fooFoo.wat -> 'foo-foo'
```
## gotchas
- when requiring the auto-exported directory from within that directory,
the resulted exports object structure is malformed. this happens due
the cyclic dependency.
[1]: https://img.shields.io/npm/v/auto-exports.svg?style=flat-square
[2]: https://www.npmjs.com/package/auto-exports