Cleanup some JS files and webpack info
This commit is contained in:
Nabeel Shahzad
+71
@@ -0,0 +1,71 @@
|
||||
'use strict';
|
||||
|
||||
const _ = require('lodash');
|
||||
const fs = require('fs-extra');
|
||||
const glob = require('glob');
|
||||
const path = require('path');
|
||||
|
||||
const minify = require('../common/minify.js');
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* Creates a [fs.copy](https://github.com/jprichardson/node-fs-extra#copy)
|
||||
* function with `srcPath` and `destPath` partially applied.
|
||||
*
|
||||
* @memberOf file
|
||||
* @param {string} srcPath The path of the file to copy.
|
||||
* @param {string} destPath The path to copy the file to.
|
||||
* @returns {Function} Returns the partially applied function.
|
||||
*/
|
||||
function copy(srcPath, destPath) {
|
||||
return _.partial(fs.copy, srcPath, destPath);
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates an object of base name and compiled template pairs that match `pattern`.
|
||||
*
|
||||
* @memberOf file
|
||||
* @param {string} pattern The glob pattern to be match.
|
||||
* @returns {Object} Returns the object of compiled templates.
|
||||
*/
|
||||
function globTemplate(pattern) {
|
||||
return _.transform(glob.sync(pattern), (result, filePath) => {
|
||||
const key = path.basename(filePath, path.extname(filePath));
|
||||
result[key] = _.template(fs.readFileSync(filePath, 'utf8'));
|
||||
}, {});
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a `minify` function with `srcPath` and `destPath` partially applied.
|
||||
*
|
||||
* @memberOf file
|
||||
* @param {string} srcPath The path of the file to minify.
|
||||
* @param {string} destPath The path to write the file to.
|
||||
* @returns {Function} Returns the partially applied function.
|
||||
*/
|
||||
function min(srcPath, destPath) {
|
||||
return _.partial(minify, srcPath, destPath);
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a [fs.writeFile](https://nodejs.org/api/fs.html#fs_fs_writefile_file_data_options_callback)
|
||||
* function with `filePath` and `data` partially applied.
|
||||
*
|
||||
* @memberOf file
|
||||
* @param {string} destPath The path to write the file to.
|
||||
* @param {string} data The data to write to the file.
|
||||
* @returns {Function} Returns the partially applied function.
|
||||
*/
|
||||
function write(destPath, data) {
|
||||
return _.partial(fs.writeFile, destPath, data);
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
module.exports = {
|
||||
copy,
|
||||
globTemplate,
|
||||
min,
|
||||
write
|
||||
};
|
||||
@@ -0,0 +1,9 @@
|
||||
'use strict';
|
||||
|
||||
const _mapping = require('../../fp/_mapping');
|
||||
const util = require('./util');
|
||||
const Hash = util.Hash;
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
module.exports = new Hash(_mapping);
|
||||
@@ -0,0 +1,39 @@
|
||||
'use strict';
|
||||
|
||||
const _ = require('lodash');
|
||||
const fs = require('fs-extra');
|
||||
const uglify = require('uglify-js');
|
||||
|
||||
const uglifyOptions = require('./uglify.options');
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* Asynchronously minifies the file at `srcPath`, writes it to `destPath`, and
|
||||
* invokes `callback` upon completion. The callback is invoked with one argument:
|
||||
* (error).
|
||||
*
|
||||
* If unspecified, `destPath` is `srcPath` with an extension of `.min.js`.
|
||||
* (e.g. the `destPath` of `path/to/foo.js` would be `path/to/foo.min.js`)
|
||||
*
|
||||
* @param {string} srcPath The path of the file to minify.
|
||||
* @param {string} [destPath] The path to write the file to.
|
||||
* @param {Function} callback The function invoked upon completion.
|
||||
* @param {Object} [option] The UglifyJS options object.
|
||||
*/
|
||||
function minify(srcPath, destPath, callback, options) {
|
||||
if (_.isFunction(destPath)) {
|
||||
if (_.isObject(callback)) {
|
||||
options = callback;
|
||||
}
|
||||
callback = destPath;
|
||||
destPath = undefined;
|
||||
}
|
||||
if (!destPath) {
|
||||
destPath = srcPath.replace(/(?=\.js$)/, '.min');
|
||||
}
|
||||
const output = uglify.minify(srcPath, _.defaults(options || {}, uglifyOptions));
|
||||
fs.writeFile(destPath, output.code, 'utf-8', callback);
|
||||
}
|
||||
|
||||
module.exports = minify;
|
||||
@@ -0,0 +1,22 @@
|
||||
'use strict';
|
||||
|
||||
/**
|
||||
* The UglifyJS options object for
|
||||
* [compress](https://github.com/mishoo/UglifyJS2#compressor-options),
|
||||
* [mangle](https://github.com/mishoo/UglifyJS2#mangler-options), and
|
||||
* [output](https://github.com/mishoo/UglifyJS2#beautifier-options) options.
|
||||
*/
|
||||
module.exports = {
|
||||
'compress': {
|
||||
'collapse_vars': true,
|
||||
'negate_iife': false,
|
||||
'pure_getters': true,
|
||||
'unsafe': true,
|
||||
'warnings': false
|
||||
},
|
||||
'output': {
|
||||
'ascii_only': true,
|
||||
'comments': /@license/,
|
||||
'max_line_len': 500
|
||||
}
|
||||
};
|
||||
+40
@@ -0,0 +1,40 @@
|
||||
'use strict';
|
||||
|
||||
const _ = require('lodash');
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* Creates a hash object. If a `properties` object is provided, its own
|
||||
* enumerable properties are assigned to the created hash.
|
||||
*
|
||||
* @memberOf util
|
||||
* @param {Object} [properties] The properties to assign to the hash.
|
||||
* @returns {Object} Returns the new hash object.
|
||||
*/
|
||||
function Hash(properties) {
|
||||
return _.transform(properties, (result, value, key) => {
|
||||
result[key] = (_.isPlainObject(value) && !(value instanceof Hash))
|
||||
? new Hash(value)
|
||||
: value;
|
||||
}, this);
|
||||
}
|
||||
|
||||
Hash.prototype = Object.create(null);
|
||||
|
||||
/**
|
||||
* This method throws any error it receives.
|
||||
*
|
||||
* @memberOf util
|
||||
* @param {Object} [error] The error object.
|
||||
*/
|
||||
function pitch(error) {
|
||||
if (error != null) {
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
module.exports = {
|
||||
Hash,
|
||||
pitch
|
||||
};
|
||||
@@ -0,0 +1,56 @@
|
||||
'use strict';
|
||||
|
||||
const _ = require('lodash');
|
||||
const async = require('async');
|
||||
const path = require('path');
|
||||
const webpack = require('webpack');
|
||||
|
||||
const file = require('../common/file');
|
||||
const util = require('../common/util');
|
||||
|
||||
const basePath = path.join(__dirname, '..', '..');
|
||||
const distPath = path.join(basePath, 'dist');
|
||||
const fpPath = path.join(basePath, 'fp');
|
||||
const filename = 'lodash.fp.js';
|
||||
|
||||
const fpConfig = {
|
||||
'entry': path.join(fpPath, '_convertBrowser.js'),
|
||||
'output': {
|
||||
'path': distPath,
|
||||
'filename': filename,
|
||||
'library': 'fp',
|
||||
'libraryTarget': 'umd'
|
||||
},
|
||||
'plugins': [
|
||||
new webpack.optimize.OccurenceOrderPlugin,
|
||||
new webpack.optimize.DedupePlugin
|
||||
]
|
||||
};
|
||||
|
||||
const mappingConfig = {
|
||||
'entry': path.join(fpPath, '_mapping.js'),
|
||||
'output': {
|
||||
'path': distPath,
|
||||
'filename': 'mapping.fp.js',
|
||||
'library': 'mapping',
|
||||
'libraryTarget': 'umd'
|
||||
}
|
||||
};
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* Creates browser builds of the FP converter and mappings at the `target` path.
|
||||
*
|
||||
* @private
|
||||
* @param {string} target The output directory path.
|
||||
*/
|
||||
function build() {
|
||||
async.series([
|
||||
_.partial(webpack, mappingConfig),
|
||||
_.partial(webpack, fpConfig),
|
||||
file.min(path.join(distPath, filename))
|
||||
], util.pitch);
|
||||
}
|
||||
|
||||
build();
|
||||
+78
@@ -0,0 +1,78 @@
|
||||
'use strict';
|
||||
|
||||
const _ = require('lodash');
|
||||
const fs = require('fs-extra');
|
||||
const path = require('path');
|
||||
|
||||
const file = require('../common/file');
|
||||
const mapping = require('../common/mapping');
|
||||
const util = require('../common/util');
|
||||
|
||||
const templatePath = path.join(__dirname, 'template/doc');
|
||||
const template = file.globTemplate(path.join(templatePath, '*.jst'));
|
||||
|
||||
const argNames = ['a', 'b', 'c', 'd'];
|
||||
|
||||
const templateData = {
|
||||
mapping,
|
||||
toArgOrder,
|
||||
toFuncList
|
||||
};
|
||||
|
||||
/**
|
||||
* Converts arranged argument `indexes` into a named argument string
|
||||
* representation of their order.
|
||||
*
|
||||
* @private
|
||||
* @param {number[]} indexes The arranged argument indexes.
|
||||
* @returns {string} Returns the named argument string.
|
||||
*/
|
||||
function toArgOrder(indexes) {
|
||||
const reordered = [];
|
||||
_.each(indexes, (newIndex, index) => {
|
||||
reordered[newIndex] = argNames[index];
|
||||
});
|
||||
return '`(' + reordered.join(', ') + ')`';
|
||||
}
|
||||
|
||||
/**
|
||||
* Converts `funcNames` into a chunked list string representation.
|
||||
*
|
||||
* @private
|
||||
* @param {string[]} funcNames The function names.
|
||||
* @returns {string} Returns the function list string.
|
||||
*/
|
||||
function toFuncList(funcNames) {
|
||||
let chunks = _.chunk(funcNames.slice().sort(), 5);
|
||||
let lastChunk = _.last(chunks);
|
||||
const lastName = lastChunk ? lastChunk.pop() : undefined;
|
||||
|
||||
chunks = _.reject(chunks, _.isEmpty);
|
||||
lastChunk = _.last(chunks);
|
||||
|
||||
let result = '`' + _.map(chunks, chunk => chunk.join('`, `') + '`').join(',\n`');
|
||||
if (lastName == null) {
|
||||
return result;
|
||||
}
|
||||
if (_.size(chunks) > 1 || _.size(lastChunk) > 1) {
|
||||
result += ',';
|
||||
}
|
||||
result += ' &';
|
||||
result += _.size(lastChunk) < 5 ? ' ' : '\n';
|
||||
return result + '`' + lastName + '`';
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* Creates the FP-Guide wiki at the `target` path.
|
||||
*
|
||||
* @private
|
||||
* @param {string} target The output file path.
|
||||
*/
|
||||
function build(target) {
|
||||
target = path.resolve(target);
|
||||
fs.writeFile(target, template.wiki(templateData), util.pitch);
|
||||
}
|
||||
|
||||
build(_.last(process.argv));
|
||||
+150
@@ -0,0 +1,150 @@
|
||||
'use strict';
|
||||
|
||||
const _ = require('lodash');
|
||||
const async = require('async');
|
||||
const glob = require('glob');
|
||||
const path = require('path');
|
||||
|
||||
const file = require('../common/file');
|
||||
const mapping = require('../common/mapping');
|
||||
const util = require('../common/util');
|
||||
|
||||
const templatePath = path.join(__dirname, 'template/modules');
|
||||
const template = file.globTemplate(path.join(templatePath, '*.jst'));
|
||||
|
||||
const aryMethods = _.union(
|
||||
mapping.aryMethod[1],
|
||||
mapping.aryMethod[2],
|
||||
mapping.aryMethod[3],
|
||||
mapping.aryMethod[4]
|
||||
);
|
||||
|
||||
const categories = [
|
||||
'array',
|
||||
'collection',
|
||||
'date',
|
||||
'function',
|
||||
'lang',
|
||||
'math',
|
||||
'number',
|
||||
'object',
|
||||
'seq',
|
||||
'string',
|
||||
'util'
|
||||
];
|
||||
|
||||
const ignored = [
|
||||
'_*.js',
|
||||
'core.js',
|
||||
'core.min.js',
|
||||
'fp.js',
|
||||
'index.js',
|
||||
'lodash.js',
|
||||
'lodash.min.js'
|
||||
];
|
||||
|
||||
/**
|
||||
* Checks if `name` is a method alias.
|
||||
*
|
||||
* @private
|
||||
* @param {string} name The name to check.
|
||||
* @returns {boolean} Returns `true` if `name` is a method alias, else `false`.
|
||||
*/
|
||||
function isAlias(name) {
|
||||
return _.has(mapping.aliasToReal, name);
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if `name` is a category name.
|
||||
*
|
||||
* @private
|
||||
* @param {string} name The name to check.
|
||||
* @returns {boolean} Returns `true` if `name` is a category name, else `false`.
|
||||
*/
|
||||
function isCategory(name) {
|
||||
return _.includes(categories, name);
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if `name` belongs to a method that's passed thru and not wrapped.
|
||||
*
|
||||
* @private
|
||||
* @param {string} name The name to check.
|
||||
* @returns {boolean} Returns `true` if `name` is of a pass thru method,
|
||||
* else `false`.
|
||||
*/
|
||||
function isThru(name) {
|
||||
return !_.includes(aryMethods, name);
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets metadata for `func`.
|
||||
*
|
||||
* @private
|
||||
* @param {Function} func The function to query.
|
||||
* @returns {*} Returns the metadata for `func`.
|
||||
*/
|
||||
function getTemplate(moduleName) {
|
||||
const data = {
|
||||
'name': _.get(mapping.aliasToReal, moduleName, moduleName),
|
||||
'mapping': mapping
|
||||
};
|
||||
|
||||
if (isAlias(moduleName)) {
|
||||
return template.alias(data);
|
||||
}
|
||||
if (isCategory(moduleName)) {
|
||||
return template.category(data);
|
||||
}
|
||||
if (isThru(moduleName)) {
|
||||
return template.thru(data);
|
||||
}
|
||||
return template.module(data);
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* Creates FP modules at the `target` path.
|
||||
*
|
||||
* @private
|
||||
* @param {string} target The output directory path.
|
||||
*/
|
||||
function build(target) {
|
||||
target = path.resolve(target);
|
||||
|
||||
const fpPath = path.join(target, 'fp');
|
||||
|
||||
// Glob existing lodash module paths.
|
||||
const modulePaths = glob.sync(path.join(target, '*.js'), {
|
||||
'nodir': true,
|
||||
'ignore': ignored.map(filename => {
|
||||
return path.join(target, filename);
|
||||
})
|
||||
});
|
||||
|
||||
// Add FP alias and remapped module paths.
|
||||
_.each([mapping.aliasToReal, mapping.remap], data => {
|
||||
_.forOwn(data, (realName, alias) => {
|
||||
const modulePath = path.join(target, alias + '.js');
|
||||
if (!_.includes(modulePaths, modulePath)) {
|
||||
modulePaths.push(modulePath);
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
const actions = modulePaths.map(modulePath => {
|
||||
const moduleName = path.basename(modulePath, '.js');
|
||||
return file.write(path.join(fpPath, moduleName + '.js'), getTemplate(moduleName));
|
||||
});
|
||||
|
||||
actions.unshift(file.copy(path.join(__dirname, '../../fp'), fpPath));
|
||||
actions.push(file.write(path.join(fpPath, '_falseOptions.js'), template._falseOptions()));
|
||||
actions.push(file.write(path.join(fpPath, '_util.js'), template._util()));
|
||||
actions.push(file.write(path.join(target, 'fp.js'), template.fp()));
|
||||
actions.push(file.write(path.join(fpPath, 'convert.js'), template.convert()));
|
||||
|
||||
async.series(actions, util.pitch);
|
||||
}
|
||||
|
||||
build(_.last(process.argv));
|
||||
@@ -0,0 +1,228 @@
|
||||
## lodash/fp
|
||||
|
||||
The `lodash/fp` module promotes a more
|
||||
[functional programming](https://en.wikipedia.org/wiki/Functional_programming)
|
||||
(FP) friendly style by exporting an instance of `lodash` with its methods wrapped
|
||||
to produce immutable auto-curried iteratee-first data-last methods.
|
||||
|
||||
## Installation
|
||||
|
||||
In a browser:
|
||||
```html
|
||||
<script src='https://cdn.jsdelivr.net/g/lodash@4(lodash.min.js+lodash.fp.min.js)'></script>
|
||||
<script>
|
||||
// Loading `lodash.fp.js` converts `_` to its fp variant.
|
||||
_.defaults({ 'a': 2, 'b': 2 })({ 'a': 1 });
|
||||
// ➜ { 'a': 1, 'b': 2 }
|
||||
|
||||
// Use `noConflict` to restore the pre-fp variant.
|
||||
var fp = _.noConflict();
|
||||
|
||||
_.defaults({ 'a': 1 }, { 'a': 2, 'b': 2 });
|
||||
// ➜ { 'a': 1, 'b': 2 }
|
||||
fp.defaults({ 'a': 2, 'b': 2 })({ 'a': 1 });
|
||||
// ➜ { 'a': 1, 'b': 2 }
|
||||
</script>
|
||||
```
|
||||
|
||||
In Node.js:
|
||||
```js
|
||||
// Load the fp build.
|
||||
var fp = require('lodash/fp');
|
||||
|
||||
// Load a method category.
|
||||
var object = require('lodash/fp/object');
|
||||
|
||||
// Load a single method for smaller builds with browserify/rollup/webpack.
|
||||
var extend = require('lodash/fp/extend');
|
||||
```
|
||||
|
||||
## Mapping
|
||||
|
||||
Immutable auto-curried iteratee-first data-last methods sound great, but what
|
||||
does that really mean for each method? Below is a breakdown of the mapping used
|
||||
to convert each method.
|
||||
|
||||
#### Capped Iteratee Arguments
|
||||
|
||||
Iteratee arguments are capped to avoid gotchas with variadic iteratees.
|
||||
```js
|
||||
// The `lodash/map` iteratee receives three arguments:
|
||||
// (value, index|key, collection)
|
||||
_.map(['6', '8', '10'], parseInt);
|
||||
// ➜ [6, NaN, 2]
|
||||
|
||||
// The `lodash/fp/map` iteratee is capped at one argument:
|
||||
// (value)
|
||||
fp.map(parseInt)(['6', '8', '10']);
|
||||
// ➜ [6, 8, 10]
|
||||
```
|
||||
|
||||
Methods that cap iteratees to one argument:<br>
|
||||
<%= toFuncList(_.keys(_.pickBy(mapping.iterateeAry, _.partial(_.eq, _, 1)))) %>
|
||||
|
||||
Methods that cap iteratees to two arguments:<br>
|
||||
<%= toFuncList(_.keys(_.pickBy(mapping.iterateeAry, _.partial(_.eq, _, 2)))) %>
|
||||
|
||||
The iteratee of `mapKeys` is capped to one argument: `(key)`
|
||||
|
||||
#### Fixed Arity
|
||||
|
||||
Methods have fixed arities to support auto-currying.
|
||||
```js
|
||||
// `lodash/padStart` accepts an optional `chars` param.
|
||||
_.padStart('a', 3, '-')
|
||||
// ➜ '--a'
|
||||
|
||||
// `lodash/fp/padStart` does not.
|
||||
fp.padStart(3)('a');
|
||||
// ➜ ' a'
|
||||
fp.padCharsStart('-')(3)('a');
|
||||
// ➜ '--a'
|
||||
```
|
||||
|
||||
Methods with a fixed arity of one:<br>
|
||||
<%= toFuncList(_.difference(mapping.aryMethod[1], _.keys(mapping.skipFixed))) %>
|
||||
|
||||
Methods with a fixed arity of two:<br>
|
||||
<%= toFuncList(_.difference(mapping.aryMethod[2], _.keys(mapping.skipFixed))) %>
|
||||
|
||||
Methods with a fixed arity of three:<br>
|
||||
<%= toFuncList(_.difference(mapping.aryMethod[3], _.keys(mapping.skipFixed))) %>
|
||||
|
||||
Methods with a fixed arity of four:<br>
|
||||
<%= toFuncList(_.difference(mapping.aryMethod[4], _.keys(mapping.skipFixed))) %>
|
||||
|
||||
#### Rearranged Arguments
|
||||
|
||||
Method arguments are rearranged to make composition easier.
|
||||
```js
|
||||
// `lodash/filter` is data-first iteratee-last:
|
||||
// (collection, iteratee)
|
||||
var compact = _.partial(_.filter, _, Boolean);
|
||||
compact(['a', null, 'c']);
|
||||
// ➜ ['a', 'c']
|
||||
|
||||
// `lodash/fp/filter` is iteratee-first data-last:
|
||||
// (iteratee, collection)
|
||||
var compact = fp.filter(Boolean);
|
||||
compact(['a', null, 'c']);
|
||||
// ➜ ['a', 'c']
|
||||
```
|
||||
|
||||
##### Most methods follow these rules
|
||||
|
||||
A fixed arity of two has an argument order of:<br>
|
||||
<%= toArgOrder(mapping.aryRearg[2]) %>
|
||||
|
||||
A fixed arity of three has an argument order of:<br>
|
||||
<%= toArgOrder(mapping.aryRearg[3]) %>
|
||||
|
||||
A fixed arity of four has an argument order of:<br>
|
||||
<%= toArgOrder(mapping.aryRearg[4]) %>
|
||||
|
||||
##### Exceptions to the rules
|
||||
|
||||
Methods that accept an array as their last or only argument:<br>
|
||||
<%= toFuncList(_.keys(mapping.methodSpread)) %>
|
||||
|
||||
Methods with unchanged argument orders:<br>
|
||||
<%= toFuncList(_.keys(mapping.skipRearg)) %>
|
||||
|
||||
Methods with custom argument orders:<br>
|
||||
<%= _.map(_.keys(mapping.methodRearg), methodName => {
|
||||
const orders = mapping.methodRearg[methodName];
|
||||
return ' * `_.' + methodName + '` has an order of ' + toArgOrder(orders);
|
||||
}).join('\n') %>
|
||||
|
||||
The iteratee of `reduceRight` has an argument order of: `(b, a)`
|
||||
|
||||
#### New Methods
|
||||
|
||||
Not all variadic methods have corresponding new method variants. Feel free to
|
||||
[request](https://github.com/lodash/lodash/blob/master/.github/CONTRIBUTING.md#feature-requests)
|
||||
any additions.
|
||||
|
||||
Methods created to accommodate Lodash’s variadic methods:<br>
|
||||
<%= toFuncList(_.keys(mapping.remap)) %>
|
||||
|
||||
#### Aliases
|
||||
|
||||
There are <%= _.size(mapping.aliasToReal) %> method aliases:<br>
|
||||
<%= _.map(_.keys(mapping.aliasToReal).sort(), alias => {
|
||||
const realName = mapping.aliasToReal[alias];
|
||||
return ' * `_.' + alias + '` is an alias of `_.' + realName + '`';
|
||||
}).join('\n') %>
|
||||
|
||||
## Placeholders
|
||||
|
||||
The placeholder argument, which defaults to `_`, may be used to fill in method
|
||||
arguments in a different order. Placeholders are filled by the first available
|
||||
arguments of the curried returned function.
|
||||
```js
|
||||
// The equivalent of `2 > 5`.
|
||||
_.gt(2)(5);
|
||||
// ➜ false
|
||||
|
||||
// The equivalent of `_.gt(5, 2)` or `5 > 2`.
|
||||
_.gt(_, 2)(5);
|
||||
// ➜ true
|
||||
```
|
||||
|
||||
## Chaining
|
||||
|
||||
The `lodash/fp` module **does not** convert chain sequence methods. See
|
||||
[Izaak Schroeder’s article](https://medium.com/making-internets/why-using-chain-is-a-mistake-9bc1f80d51ba)
|
||||
on using functional composition as an alternative to method chaining.
|
||||
|
||||
## Convert
|
||||
|
||||
Although `lodash/fp` & its method modules come pre-converted, there are times
|
||||
when you may want to customize the conversion. That’s when the `convert` method
|
||||
comes in handy.
|
||||
```js
|
||||
// Every option is `true` by default.
|
||||
var _fp = fp.convert({
|
||||
// Specify capping iteratee arguments.
|
||||
'cap': true,
|
||||
// Specify currying.
|
||||
'curry': true,
|
||||
// Specify fixed arity.
|
||||
'fixed': true,
|
||||
// Specify immutable operations.
|
||||
'immutable': true,
|
||||
// Specify rearranging arguments.
|
||||
'rearg': true
|
||||
});
|
||||
|
||||
// The `convert` method is available on each method too.
|
||||
var mapValuesWithKey = fp.mapValues.convert({ 'cap': false });
|
||||
|
||||
// Here’s an example of disabling iteratee argument caps to access the `key` param.
|
||||
mapValuesWithKey(function(value, key) {
|
||||
return key == 'a' ? -1 : value;
|
||||
})({ 'a': 1, 'b': 1 });
|
||||
// => { 'a': -1, 'b': 1 }
|
||||
```
|
||||
|
||||
Manual conversions are also possible with the `convert` module.
|
||||
```js
|
||||
var convert = require('lodash/fp/convert');
|
||||
|
||||
// Convert by name.
|
||||
var assign = convert('assign', require('lodash.assign'));
|
||||
|
||||
// Convert by object.
|
||||
var fp = convert({
|
||||
'assign': require('lodash.assign'),
|
||||
'chunk': require('lodash.chunk')
|
||||
});
|
||||
|
||||
// Convert by `lodash` instance.
|
||||
var fp = convert(lodash.runInContext());
|
||||
```
|
||||
|
||||
## Tooling
|
||||
|
||||
Use [eslint-plugin-lodash-fp](https://www.npmjs.com/package/eslint-plugin-lodash-fp)
|
||||
to help use `lodash/fp` more efficiently.
|
||||
@@ -0,0 +1,7 @@
|
||||
module.exports = {
|
||||
'cap': false,
|
||||
'curry': false,
|
||||
'fixed': false,
|
||||
'immutable': false,
|
||||
'rearg': false
|
||||
};
|
||||
@@ -0,0 +1,14 @@
|
||||
module.exports = {
|
||||
'ary': require('../ary'),
|
||||
'assign': require('../_baseAssign'),
|
||||
'clone': require('../clone'),
|
||||
'curry': require('../curry'),
|
||||
'forEach': require('../_arrayEach'),
|
||||
'isArray': require('../isArray'),
|
||||
'isFunction': require('../isFunction'),
|
||||
'iteratee': require('../iteratee'),
|
||||
'keys': require('../_baseKeys'),
|
||||
'rearg': require('../rearg'),
|
||||
'toInteger': require('../toInteger'),
|
||||
'toPath': require('../toPath')
|
||||
};
|
||||
@@ -0,0 +1 @@
|
||||
module.exports = require('./<%= name %>');
|
||||
@@ -0,0 +1,2 @@
|
||||
var convert = require('./convert');
|
||||
module.exports = convert(require('../<%= name %>'));
|
||||
@@ -0,0 +1,18 @@
|
||||
var baseConvert = require('./_baseConvert'),
|
||||
util = require('./_util');
|
||||
|
||||
/**
|
||||
* Converts `func` of `name` to an immutable auto-curried iteratee-first data-last
|
||||
* version with conversion `options` applied. If `name` is an object its methods
|
||||
* will be converted.
|
||||
*
|
||||
* @param {string} name The name of the function to wrap.
|
||||
* @param {Function} [func] The function to wrap.
|
||||
* @param {Object} [options] The options object. See `baseConvert` for more details.
|
||||
* @returns {Function|Object} Returns the converted function or object.
|
||||
*/
|
||||
function convert(name, func, options) {
|
||||
return baseConvert(util, name, func, options);
|
||||
}
|
||||
|
||||
module.exports = convert;
|
||||
@@ -0,0 +1,2 @@
|
||||
var _ = require('./lodash.min').runInContext();
|
||||
module.exports = require('./fp/_baseConvert')(_, _);
|
||||
@@ -0,0 +1,5 @@
|
||||
var convert = require('./convert'),
|
||||
func = convert('<%= name %>', require('../<%= _.get(mapping.remap, name, name) %>'));
|
||||
|
||||
func.placeholder = require('./placeholder');
|
||||
module.exports = func;
|
||||
@@ -0,0 +1,5 @@
|
||||
var convert = require('./convert'),
|
||||
func = convert('<%= name %>', require('../<%= _.get(mapping.remap, name, name) %>'), require('./_falseOptions'));
|
||||
|
||||
func.placeholder = require('./placeholder');
|
||||
module.exports = func;
|
||||
@@ -0,0 +1,31 @@
|
||||
'use strict';
|
||||
|
||||
const async = require('async');
|
||||
const path = require('path');
|
||||
|
||||
const file = require('../common/file');
|
||||
const util = require('../common/util');
|
||||
|
||||
const basePath = path.join(__dirname, '..', '..');
|
||||
const distPath = path.join(basePath, 'dist');
|
||||
const filename = 'lodash.js';
|
||||
|
||||
const baseLodash = path.join(basePath, filename);
|
||||
const distLodash = path.join(distPath, filename);
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* Creates browser builds of Lodash at the `target` path.
|
||||
*
|
||||
* @private
|
||||
* @param {string} target The output directory path.
|
||||
*/
|
||||
function build() {
|
||||
async.series([
|
||||
file.copy(baseLodash, distLodash),
|
||||
file.min(distLodash)
|
||||
], util.pitch);
|
||||
}
|
||||
|
||||
build();
|
||||
@@ -0,0 +1,83 @@
|
||||
'use strict';
|
||||
|
||||
const _ = require('lodash');
|
||||
const docdown = require('docdown');
|
||||
const fs = require('fs-extra');
|
||||
const path = require('path');
|
||||
|
||||
const util = require('../common/util');
|
||||
|
||||
const basePath = path.join(__dirname, '..', '..');
|
||||
const docPath = path.join(basePath, 'doc');
|
||||
const readmePath = path.join(docPath, 'README.md');
|
||||
|
||||
const pkg = require('../../package.json');
|
||||
const version = pkg.version;
|
||||
|
||||
const config = {
|
||||
'base': {
|
||||
'path': path.join(basePath, 'lodash.js'),
|
||||
'title': `<a href="https://lodash.com/">lodash</a> <span>v${ version }</span>`,
|
||||
'toc': 'categories',
|
||||
'url': `https://github.com/lodash/lodash/blob/${ version }/lodash.js`
|
||||
},
|
||||
'github': {
|
||||
'style': 'github',
|
||||
'sublinks': [npmLink('Ⓝ', 'See the npm package')]
|
||||
},
|
||||
'site': {
|
||||
'entryLink': '<a href="${entryHref}" class="fa fa-link"></a>',
|
||||
'sourceLink': '[source](${sourceHref})',
|
||||
'tocHref': '',
|
||||
'tocLink': '',
|
||||
'sublinks': [npmLink('npm package')]
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Composes a npm link from `text` and optional `title`.
|
||||
*
|
||||
* @private
|
||||
* @param {string} text The link text.
|
||||
* @param {string} [title] The link title.
|
||||
* @returns {string} Returns the composed npm link.
|
||||
*/
|
||||
function npmLink(text, title) {
|
||||
return (
|
||||
'<% if (name == "templateSettings" || !/^(?:methods|properties|seq)$/i.test(category)) {' +
|
||||
'print(' +
|
||||
'"[' + text + '](https://www.npmjs.com/package/lodash." + name.toLowerCase() + ' +
|
||||
'"' + (title == null ? '' : ' \\"' + title + '\\"') + ')"' +
|
||||
');' +
|
||||
'} %>'
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Post-process `markdown` to make adjustments.
|
||||
*
|
||||
* @private
|
||||
* @param {string} markdown The markdown to process.
|
||||
* @returns {string} Returns the processed markdown.
|
||||
*/
|
||||
function postprocess(markdown) {
|
||||
// Wrap symbol property identifiers in brackets.
|
||||
return markdown.replace(/\.(Symbol\.(?:[a-z]+[A-Z]?)+)/g, '[$1]');
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* Creates the documentation markdown formatted for 'github' or 'site'.
|
||||
*
|
||||
* @private
|
||||
* @param {string} type The format type.
|
||||
*/
|
||||
function build(type) {
|
||||
const options = _.defaults({}, config.base, config[type]);
|
||||
const markdown = docdown(options);
|
||||
|
||||
fs.writeFile(readmePath, postprocess(markdown), util.pitch);
|
||||
}
|
||||
|
||||
build(_.last(process.argv));
|
||||
@@ -0,0 +1,34 @@
|
||||
'use strict';
|
||||
|
||||
const _ = require('lodash');
|
||||
const async = require('async');
|
||||
const path = require('path');
|
||||
|
||||
const file = require('../common/file');
|
||||
const util = require('../common/util');
|
||||
|
||||
const basePath = path.join(__dirname, '..', '..');
|
||||
const distPath = path.join(basePath, 'dist');
|
||||
|
||||
const filePairs = [
|
||||
[path.join(distPath, 'lodash.core.js'), 'core.js'],
|
||||
[path.join(distPath, 'lodash.core.min.js'), 'core.min.js'],
|
||||
[path.join(distPath, 'lodash.min.js'), 'lodash.min.js']
|
||||
];
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* Creates supplementary Lodash modules at the `target` path.
|
||||
*
|
||||
* @private
|
||||
* @param {string} target The output directory path.
|
||||
*/
|
||||
function build(target) {
|
||||
const actions = _.map(filePairs, pair =>
|
||||
file.copy(pair[0], path.join(target, pair[1])));
|
||||
|
||||
async.series(actions, util.pitch);
|
||||
}
|
||||
|
||||
build(_.last(process.argv));
|
||||
+224
@@ -0,0 +1,224 @@
|
||||
'use strict';
|
||||
|
||||
const _ = require('lodash');
|
||||
const cheerio = require('cheerio');
|
||||
const fs = require('fs');
|
||||
const marky = require('marky-markdown');
|
||||
const path = require('path');
|
||||
const util = require('../common/util');
|
||||
|
||||
const basePath = path.join(__dirname, '..', '..');
|
||||
const docPath = path.join(basePath, 'doc');
|
||||
const readmePath = path.join(docPath, 'README.md');
|
||||
|
||||
const highlights = {
|
||||
'html': [
|
||||
'string'
|
||||
],
|
||||
'js': [
|
||||
'comment',
|
||||
'console',
|
||||
'delimiter',
|
||||
'method',
|
||||
'modifier',
|
||||
'name',
|
||||
'numeric',
|
||||
'string',
|
||||
'support',
|
||||
'type'
|
||||
]
|
||||
};
|
||||
|
||||
const exts = _.keys(highlights);
|
||||
|
||||
/**
|
||||
* Converts Lodash method references into documentation links.
|
||||
*
|
||||
* @private
|
||||
* @param {Object} $ The Cheerio object.
|
||||
*/
|
||||
function autoLink($) {
|
||||
$('.doc-container code').each(function() {
|
||||
const $code = $(this);
|
||||
const html = $code.html();
|
||||
if (/^_\.\w+$/.test(html)) {
|
||||
const id = html.split('.')[1];
|
||||
$code.replaceWith(`<a href="#${ id }"><code>_.${ id }</code></a>`);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Removes horizontal rules from the document.
|
||||
*
|
||||
* @private
|
||||
* @param {Object} $ The Cheerio object.
|
||||
*/
|
||||
function removeHorizontalRules($) {
|
||||
$('hr').remove();
|
||||
}
|
||||
|
||||
/**
|
||||
* Removes marky-markdown specific ids and class names.
|
||||
*
|
||||
* @private
|
||||
* @param {Object} $ The Cheerio object.
|
||||
*/
|
||||
function removeMarkyAttributes($) {
|
||||
$('[id^="user-content-"]')
|
||||
.attr('class', null)
|
||||
.attr('id', null);
|
||||
|
||||
$(':header:not(h3) > a').each(function() {
|
||||
const $a = $(this);
|
||||
$a.replaceWith($a.html());
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Renames "_" id and anchor references to "lodash".
|
||||
*
|
||||
* @private
|
||||
* @param {Object} $ The Cheerio object.
|
||||
*/
|
||||
function renameLodashId($) {
|
||||
$('#_').attr('id', 'lodash');
|
||||
$('[href="#_"]').attr('href', '#lodash');
|
||||
}
|
||||
|
||||
/**
|
||||
* Repairs broken marky-markdown headers.
|
||||
* See https://github.com/npm/marky-markdown/issues/217 for more details.
|
||||
*
|
||||
* @private
|
||||
* @param {Object} $ The Cheerio object.
|
||||
*/
|
||||
function repairMarkyHeaders($) {
|
||||
$('p:empty + h3').prev().remove();
|
||||
|
||||
$('h3 ~ p:empty').each(function() {
|
||||
const $p = $(this);
|
||||
let node = this.prev;
|
||||
while ((node = node.prev) && node.name != 'h3' && node.name != 'p') {
|
||||
$p.prepend(node.next);
|
||||
}
|
||||
});
|
||||
|
||||
$('h3 code em').parent().each(function() {
|
||||
const $code = $(this);
|
||||
$code.html($code.html().replace(/<\/?em>/g, '_'));
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Cleans up highlights blocks by removing extraneous class names and elements.
|
||||
*
|
||||
* @private
|
||||
* @param {Object} $ The Cheerio object.
|
||||
*/
|
||||
function tidyHighlights($) {
|
||||
$('.highlight').each(function() {
|
||||
let $spans;
|
||||
const $parent = $(this);
|
||||
const classes = $parent.find('.source,.text').first().attr('class').split(' ');
|
||||
const ext = _(classes).intersection(exts).last();
|
||||
|
||||
$parent.addClass(ext);
|
||||
|
||||
// Remove line indicators for single line snippets.
|
||||
$parent.children('pre').each(function() {
|
||||
const $divs = $(this).children('div');
|
||||
if ($divs.length == 1) {
|
||||
$divs.replaceWith($divs.html());
|
||||
}
|
||||
});
|
||||
// Remove extraneous class names.
|
||||
$parent.find('[class]').each(function() {
|
||||
const $element = $(this);
|
||||
const classes = $element.attr('class').split(' ');
|
||||
const attr = _(classes).intersection(highlights[ext]).join(' ');
|
||||
$element.attr('class', attr || null);
|
||||
});
|
||||
// Collapse nested comment highlights.
|
||||
$parent.find(`[class~="comment"]`).each(function() {
|
||||
const $element = $(this);
|
||||
$element.text($element.text().trim());
|
||||
});
|
||||
// Collapse nested string highlights.
|
||||
$parent.find(`[class~="string"]`).each(function() {
|
||||
const $element = $(this);
|
||||
$element.text($element.text());
|
||||
});
|
||||
// Collapse nested spans.
|
||||
while (($spans = $parent.find('span:not([class])')).length) {
|
||||
$spans.each(function() {
|
||||
let $span = $(this);
|
||||
while ($span[0] && $span[0].name == 'span' && !$span.attr('class')) {
|
||||
const $parent = $span.parent();
|
||||
$span.replaceWith($span.html());
|
||||
$span = $parent;
|
||||
}
|
||||
});
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* Creates the documentation HTML.
|
||||
*
|
||||
* @private
|
||||
*/
|
||||
function build() {
|
||||
const markdown = fs
|
||||
// Load markdown.
|
||||
.readFileSync(readmePath, 'utf8')
|
||||
// Uncomment docdown HTML hints.
|
||||
.replace(/(<)!--\s*|\s*--(>)/g, '$1$2')
|
||||
// Convert source and npm package links to anchors.
|
||||
.replace(/\[source\]\(([^)]+)\) \[npm package\]\(([^)]+)\)/g, (match, href1, href2) =>
|
||||
`<p><a href="${ href1 }">source</a> <a href="${ href2 }">npm package</a></p>`
|
||||
);
|
||||
|
||||
const $ = cheerio.load(marky(markdown, {
|
||||
'enableHeadingLinkIcons': false,
|
||||
'sanitize': false
|
||||
}));
|
||||
|
||||
const $header = $('h1').first().remove();
|
||||
const version = $header.find('span').first().text().trim().slice(1);
|
||||
|
||||
// Auto-link Lodash method references.
|
||||
autoLink($);
|
||||
// Rename "_" id references to "lodash".
|
||||
renameLodashId($);
|
||||
// Remove docdown horizontal rules.
|
||||
removeHorizontalRules($);
|
||||
// Remove marky-markdown attribute additions.
|
||||
removeMarkyAttributes($);
|
||||
// Repair marky-markdown wrapping around headers.
|
||||
repairMarkyHeaders($);
|
||||
// Cleanup highlights.
|
||||
tidyHighlights($);
|
||||
|
||||
const html = [
|
||||
// Append YAML front matter.
|
||||
'---',
|
||||
'id: docs',
|
||||
'layout: docs',
|
||||
'title: Lodash Documentation',
|
||||
'version: ' + (version || null),
|
||||
'---',
|
||||
'',
|
||||
// Wrap in raw tags to avoid Liquid template tag processing.
|
||||
'{% raw %}',
|
||||
$.html().trim(),
|
||||
'{% endraw %}',
|
||||
''
|
||||
].join('\n');
|
||||
|
||||
fs.writeFile(path.join(docPath, version + '.html'), html, util.pitch);
|
||||
}
|
||||
|
||||
build();
|
||||
Reference in New Issue
Block a user