1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
|
# option-chain [](https://travis-ci.org/avajs/option-chain) [](https://coveralls.io/github/avajs/option-chain?branch=master)
> Use fluent property chains in lieu of options objects
## Install
```
$ npm install --save option-chain
```
## Usage
```js
const optionChain = require('option-chain');
const optionDefinition = {
defaults: {
bar: false
},
chainableMethods: {
foo: {foo: true},
notFoo: {foo: false},
bar: {bar: true}
}
};
function printOptionsAndArgs(options, args) {
console.log(options);
if (args.length) {
console.log(args);
}
}
const fn = optionChain(optionDefinition, printOptionsAndArgs);
fn();
//=> [{bar: false}]
fn.bar();
//=> [{bar: true}]
fn.foo.bar();
//=> [{foo: true, bar: false}]
fn.foo('a', 'b');
//=> [{foo: true, bar: false}]
//=> ['a', 'b']
```
## API
### optionChain(options, callback, [target])
#### options
##### chainableMethods
*Required*<br>
Type: `Object`
A map of chainable property names to the options set by adding property to the chain.
Given the following:
```js
const chainableMethods = {
foo: {foo: true},
notFoo: {foo: false},
bar: {bar: true},
both: {foo: true, bar: true}
}
```
Then:
- `fn.foo` would set `foo` to `true`.
- `fn.bar` would set `bar` to `true`.
- `fn.both` sets both `foo` and `bar` to `true`.
- The last property in the chain takes precedence, so `fn.foo.notFoo` would result in `foo` being `false`.
##### defaults
Type: `Object`<br>
Default: `{}`
A set of default starting properties.
##### spread
Type: `boolean`<br>
Default: `false`
By default, any arguments passed to the wrapper are passed as an array to the second argument of the wrapped function. When this is `true`, additional arguments will be spread out as additional arguments:
```js
function withoutSpread(opts, args) {
let foo = args[0];
let bar = args[1];
// ...
}
function withSpread(opts, foo, bar) {
// ...
}
```
#### callback
Type: `Function`
This callback is called with the accumulated options as the first argument. Depending on the value of `options.spread`, arguments passed to the wrapper will either be an array as the second argument or spread out as the 2nd, 3rd, 4th... arguments.
#### target
If supplied, the `target` object is extended with the property getters and returned. Otherwise a wrapper function is created for `options.defaults`, then that wrapper is extended and returned.
*Hint:* If you want to extend a `target` and add a method that simply uses the defaults, add a chainable method definition with an empty spec:
```js
const chainableMethods = {
defaultMethodName: {}
}
```
## License
MIT © [James Talmage](https://github.com/jamestalmage)
|
