Mirrors/lodash
1
0
Fork 0
mirror of https://github.com/whoisclebs/lodash.git synced 2026-02-11 11:27:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove more methods.

Browse Source
This commit is contained in:
John-David Dalton
2018-06-15 06:15:16 -04:00
parent 51c562256b
commit 4ba0f8b612
8 changed files with 0 additions and 572 deletions
Download Patch File Download Diff File Expand all files Collapse all files

25
ary.js
View File

@@ -1,25 +0,0 @@
import createWrap from './.internal/createWrap.js'
/** Used to compose bitmasks for function metadata. */
const WRAP_ARY_FLAG = 128
/**
* Creates a function that invokes `func`, with up to `n` arguments,
* ignoring any additional arguments.
*
* @since 3.0.0
* @category Function
* @param {Function} func The function to cap arguments for.
* @param {number} [n=func.length] The arity cap.
* @returns {Function} Returns the new capped function.
* @example
*
* map(['6', '8', '10'], ary(parseInt, 1))
* // => [6, 8, 10]
*/
function ary(func, n) {
n = (func && n == null) ? func.length : n
return createWrap(func, WRAP_ARY_FLAG, undefined, undefined, undefined, undefined, n)
}
export default ary

35
assignWith.js
View File

@@ -1,35 +0,0 @@
import copyObject from './.internal/copyObject.js'
import createAssigner from './.internal/createAssigner.js'
import keys from './keys.js'
/**
* This method is like `assign` except that it accepts `customizer`
* which is invoked to produce the assigned values. If `customizer` returns
* `undefined`, assignment is handled by the method instead. The `customizer`
* is invoked with five arguments: (objValue, srcValue, key, object, source).
*
* **Note:** This method mutates `object`.
*
* @since 4.0.0
* @category Object
* @param {Object} object The destination object.
* @param {...Object} sources The source objects.
* @param {Function} [customizer] The function to customize assigned values.
* @returns {Object} Returns `object`.
* @see assignInWith
* @example
*
* function customizer(objValue, srcValue) {
* return isUndefined(objValue) ? srcValue : objValue
* }
*
* const defaults = partialRight(assignWith, customizer)
*
* defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 })
* // => { 'a': 1, 'b': 2 }
*/
const assignWith = createAssigner((object, source, srcIndex, customizer) => {
copyObject(source, keys(source), object, customizer)
})
export default assignWith

66
bindKey.js
View File

@@ -1,66 +0,0 @@
import createWrap from './.internal/createWrap.js'
import getHolder from './.internal/getHolder.js'
import replaceHolders from './.internal/replaceHolders.js'
/** Used to compose bitmasks for function metadata. */
const WRAP_BIND_FLAG = 1
const WRAP_BIND_KEY_FLAG = 2
const WRAP_PARTIAL_FLAG = 32
/**
* Creates a function that invokes the method at `object[key]` with `partials`
* prepended to the arguments it receives.
*
* This method differs from `bind` by allowing bound functions to reference
* methods that may be redefined or don't yet exist. See
* [Peter Michaux's article](http://peter.michaux.ca/articles/lazy-function-definition-pattern)
* for more details.
*
* The `bindKey.placeholder` value, which defaults to `_` in monolithic
* builds, may be used as a placeholder for partially applied arguments.
*
* @since 0.10.0
* @category Function
* @param {Object} object The object to invoke the method on.
* @param {string} key The key of the method.
* @param {...*} [partials] The arguments to be partially applied.
* @returns {Function} Returns the new bound function.
* @example
*
* const object = {
* 'user': 'fred',
* 'greet': function(greeting, punctuation) {
* return greeting + ' ' + this.user + punctuation
* }
* }
*
* const bound = bindKey(object, 'greet', 'hi')
* bound('!')
* // => 'hi fred!'
*
* object.greet = function(greeting, punctuation) {
* return greeting + 'ya ' + this.user + punctuation
* }
*
* bound('!')
* // => 'hiya fred!'
*
* // Bound with placeholders.
* const bound = bindKey(object, 'greet', _, '!')
* bound('hi')
* // => 'hiya fred!'
*/
function bindKey(object, key, ...partials) {
let holders
let bitmask = WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG
if (partials.length) {
holders = replaceHolders(partials, getHolder(bindKey))
bitmask |= WRAP_PARTIAL_FLAG
}
return createWrap(key, bitmask, object, partials, holders)
}
// Assign default placeholders.
bindKey.placeholder = {}
export default bindKey

53
curry.js
View File

@@ -1,53 +0,0 @@
import createWrap from './.internal/createWrap.js'
/** Used to compose bitmasks for function metadata. */
const WRAP_CURRY_FLAG = 8
/**
* Creates a function that accepts arguments of `func` and either invokes
* `func` returning its result, if at least `arity` number of arguments have
* been provided, or returns a function that accepts the remaining `func`
* arguments, and so on. The arity of `func` may be specified if `func.length`
* is not sufficient.
*
* The `curry.placeholder` value, which defaults to `_` in monolithic builds,
* may be used as a placeholder for provided arguments.
*
* **Note:** This method doesn't set the "length" property of curried functions.
*
* @since 2.0.0
* @category Function
* @param {Function} func The function to curry.
* @param {number} [arity=func.length] The arity of `func`.
* @returns {Function} Returns the new curried function.
* @example
*
* const abc = function(a, b, c) {
* return [a, b, c]
* }
*
* const curried = curry(abc)
*
* curried(1)(2)(3)
* // => [1, 2, 3]
*
* curried(1, 2)(3)
* // => [1, 2, 3]
*
* curried(1, 2, 3)
* // => [1, 2, 3]
*
* // Curried with placeholders.
* curried(1)(_, 3)(2)
* // => [1, 2, 3]
*/
function curry(func, arity) {
const result = createWrap(func, WRAP_CURRY_FLAG, undefined, undefined, undefined, undefined, undefined, arity)
result.placeholder = curry.placeholder
return result
}
// Assign default placeholders.
curry.placeholder = {}
export default curry

50
curryRight.js
View File

@@ -1,50 +0,0 @@
import createWrap from './.internal/createWrap.js'
/** Used to compose bitmasks for function metadata. */
const WRAP_CURRY_RIGHT_FLAG = 16
/**
* This method is like `curry` except that arguments are applied to `func`
* in the manner of `partialRight` instead of `partial`.
*
* The `curryRight.placeholder` value, which defaults to `_` in monolithic
* builds, may be used as a placeholder for provided arguments.
*
* **Note:** This method doesn't set the "length" property of curried functions.
*
* @since 3.0.0
* @category Function
* @param {Function} func The function to curry.
* @param {number} [arity=func.length] The arity of `func`.
* @returns {Function} Returns the new curried function.
* @example
*
* const abc = function(a, b, c) {
* return [a, b, c]
* }
*
* const curried = curryRight(abc)
*
* curried(3)(2)(1)
* // => [1, 2, 3]
*
* curried(2, 3)(1)
* // => [1, 2, 3]
*
* curried(1, 2, 3)
* // => [1, 2, 3]
*
* // Curried with placeholders.
* curried(3)(1, _)(2)
* // => [1, 2, 3]
*/
function curryRight(func, arity) {
const result = createWrap(func, WRAP_CURRY_RIGHT_FLAG, undefined, undefined, undefined, undefined, undefined, arity)
result.placeholder = curryRight.placeholder
return result
}
// Assign default placeholders.
curryRight.placeholder = {}
export default curryRight

40
find.js
View File

@@ -1,40 +0,0 @@
import findIndex from './findIndex.js'
import isArrayLike from './isArrayLike'
import keys from './keys'
/**
* Iterates over elements of `collection`, returning the first element
* `predicate` returns truthy for. The predicate is invoked with three
* arguments: (value, index|key, collection).
*
* @since 0.1.0
* @category Collection
* @param {Array|Object} collection The collection to inspect.
* @param {Function} predicate The function invoked per iteration.
* @param {number} [fromIndex=0] The index to search from.
* @returns {*} Returns the matched element, else `undefined`.
* @see findIndex, findKey, findLast, findLastIndex, findLastKey
* @example
*
* const users = [
* { 'user': 'barney', 'age': 36, 'active': true },
* { 'user': 'fred', 'age': 40, 'active': false },
* { 'user': 'pebbles', 'age': 1, 'active': true }
* ]
*
* find(users, ({ age }) => age < 40)
* // => object for 'barney'
*/
function find(collection, predicate, fromIndex) {
let iteratee
const iterable = Object(collection)
if (!isArrayLike(collection)) {
collection = keys(collection)
iteratee = (key) => predicate(iterable[key], key, iterable)
}
const index = findIndex(collection, predicate, fromIndex)
return index > -1 ? iterable[iteratee ? collection[index] : index] : undefined
}
export default find

238
template.js
View File

@@ -1,238 +0,0 @@
import assignInWith from './assignInWith.js'
import attempt from './attempt.js'
import baseValues from './.internal/baseValues.js'
import customDefaultsAssignIn from './.internal/customDefaultsAssignIn.js'
import isError from './isError.js'
import keys from './keys.js'
import reInterpolate from './.internal/reInterpolate.js'
import templateSettings from './templateSettings.js'
/** Used to match empty string literals in compiled template source. */
const reEmptyStringLeading = /\b__p \+= '';/g
const reEmptyStringMiddle = /\b(__p \+=) '' \+/g
const reEmptyStringTrailing = /(__e\(.*?\)|\b__t\)) \+\n'';/g
/**
* Used to match
* [ES template delimiters](http://ecma-international.org/ecma-262/7.0/#sec-template-literal-lexical-components).
*/
const reEsTemplate = /\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g
/** Used to ensure capturing order of template delimiters. */
const reNoMatch = /($^)/
/** Used to match unescaped characters in compiled string literals. */
const reUnescapedString = /['\n\r\u2028\u2029\\]/g
/** Used to escape characters for inclusion in compiled string literals. */
const stringEscapes = {
'\\': '\\',
"'": "'",
'\n': 'n',
'\r': 'r',
'\u2028': 'u2028',
'\u2029': 'u2029'
}
/**
* Creates a compiled template function that can interpolate data properties
* in "interpolate" delimiters, HTML-escape interpolated data properties in
* "escape" delimiters, and execute JavaScript in "evaluate" delimiters. Data
* properties may be accessed as free variables in the template. If a setting
* object is given, it takes precedence over `templateSettings` values.
*
* **Note:** In the development build `template` utilizes
* [sourceURLs](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl)
* for easier debugging.
*
* For more information on precompiling templates see
* [lodash's custom builds documentation](https://lodash.com/custom-builds).
*
* For more information on Chrome extension sandboxes see
* [Chrome's extensions documentation](https://developer.chrome.com/extensions/sandboxingEval).
*
* @since 0.1.0
* @category String
* @param {string} [string=''] The template string.
* @param {Object} [options={}] The options object.
* @param {RegExp} [options.escape=templateSettings.escape]
* The HTML "escape" delimiter.
* @param {RegExp} [options.evaluate=templateSettings.evaluate]
* The "evaluate" delimiter.
* @param {Object} [options.imports=templateSettings.imports]
* An object to import into the template as free variables.
* @param {RegExp} [options.interpolate=templateSettings.interpolate]
* The "interpolate" delimiter.
* @param {string} [options.sourceURL='templateSources[n]']
* The sourceURL of the compiled template.
* @param {string} [options.variable='obj']
* The data object variable name.
* @returns {Function} Returns the compiled template function.
* @example
*
* // Use the "interpolate" delimiter to create a compiled template.
* let compiled = template('hello <%= user %>!')
* compiled({ 'user': 'fred' })
* // => 'hello fred!'
*
* // Use the HTML "escape" delimiter to escape data property values.
* let compiled = template('<b><%- value %></b>')
* compiled({ 'value': '<script>' })
* // => '<b>&lt;script&gt;</b>'
*
* // Use the "evaluate" delimiter to execute JavaScript and generate HTML.
* let compiled = template('<% forEach(users, function(user) { %><li><%- user %></li><% })%>')
* compiled({ 'users': ['fred', 'barney'] })
* // => '<li>fred</li><li>barney</li>'
*
* // Use the internal `print` function in "evaluate" delimiters.
* let compiled = template('<% print("hello " + user)%>!')
* compiled({ 'user': 'barney' })
* // => 'hello barney!'
*
* // Use the ES template literal delimiter as an "interpolate" delimiter.
* // Disable support by replacing the "interpolate" delimiter.
* let compiled = template('hello ${ user }!')
* compiled({ 'user': 'pebbles' })
* // => 'hello pebbles!'
*
* // Use backslashes to treat delimiters as plain text.
* let compiled = template('<%= "\\<%- value %\\>" %>')
* compiled({ 'value': 'ignored' })
* // => '<%- value %>'
*
* // Use the `imports` option to import `jQuery` as `jq`.
* const text = '<% jq.each(users, function(user) { %><li><%- user %></li><% })%>'
* let compiled = template(text, { 'imports': { 'jq': jQuery } })
* compiled({ 'users': ['fred', 'barney'] })
* // => '<li>fred</li><li>barney</li>'
*
* // Use the `sourceURL` option to specify a custom sourceURL for the template.
* let compiled = template('hello <%= user %>!', { 'sourceURL': '/basic/greeting.jst' })
* compiled(data)
* // => Find the source of "greeting.jst" under the Sources tab or Resources panel of the web inspector.
*
* // Use the `variable` option to ensure a with-statement isn't used in the compiled template.
* let compiled = template('hi <%= data.user %>!', { 'variable': 'data' })
* compiled.source
* // => function(data) {
* // const __t, __p = '';
* // __p += 'hi ' + ((__t = ( data.user )) == null ? '' : __t) + '!';
* // return __p;
* // }
*
* // Use custom template delimiters.
* templateSettings.interpolate = /{{([\s\S]+?)}}/g
* let compiled = template('hello {{ user }}!')
* compiled({ 'user': 'mustache' })
* // => 'hello mustache!'
*
* // Use the `source` property to inline compiled templates for meaningful
* // line numbers in error messages and stack traces.
* fs.writeFileSync(path.join(process.cwd(), 'jst.js'), '\
* const JST = {\
* "main": ' + template(mainText).source + '\
* };\
* ')
*/
function template(string, options) {
// Based on John Resig's `tmpl` implementation
// (http://ejohn.org/blog/javascript-micro-templating/)
// and Laura Doktorova's doT.js (https://github.com/olado/doT).
const settings = templateSettings.imports.templateSettings || templateSettings
options = assignInWith({}, options, settings, customDefaultsAssignIn)
const imports = assignInWith({}, options.imports, settings.imports, customDefaultsAssignIn)
const importsKeys = keys(imports)
const importsValues = baseValues(imports, importsKeys)
let isEscaping
let isEvaluating
let index = 0
const interpolate = options.interpolate || reNoMatch
let source = "__p += '"
// Compile the regexp to match each delimiter.
const reDelimiters = RegExp(`${[
(options.escape || reNoMatch).source,
interpolate.source,
(interpolate === reInterpolate ? reEsTemplate : reNoMatch).source,
(options.evaluate || reNoMatch).source
].join('|')}|$`, 'g')
// Use a sourceURL for easier debugging.
const sourceURL = 'sourceURL' in options
? `//# sourceURL=${options.sourceURL}\n`
: ''
string.replace(reDelimiters, (
match,
escapeValue,
interpolateValue,
esTemplateValue,
evaluateValue,
offset
) => {
interpolateValue || (interpolateValue = esTemplateValue)
// Escape characters that can't be included in string literals.
source += string
.slice(index, offset)
.replace(reUnescapedString, (chr) => `\\${stringEscapes[chr]}`)
// Replace delimiters with snippets.
if (escapeValue) {
isEscaping = true
source += `' +\n__e(${escapeValue}) +\n'`
}
if (evaluateValue) {
isEvaluating = true
source += `';\n${evaluateValue};\n__p += '`
}
if (interpolateValue) {
source += `' +\n((__t = (${interpolateValue})) == null ? '' : __t) +\n'`
}
index = offset + match.length
// The JS engine embedded in Adobe products needs `match` returned in
// order to produce the correct `offset` value.
return match
})
source += "';\n"
// If `variable` is not specified wrap a with-statement around the generated
// code to add the data object to the top of the scope chain.
const variable = options.variable
if (!variable) {
source = `with (obj) {\n${source}\n}\n`
}
// Cleanup code by stripping empty strings.
source = (isEvaluating ? source.replace(reEmptyStringLeading, '') : source)
.replace(reEmptyStringMiddle, '$1')
.replace(reEmptyStringTrailing, '$1;')
// Frame code as the function body.
source = `function(${variable || 'obj'}) {\n` +
`${variable ? '' : 'obj || (obj = {});\n'}` +
`var __t, __p = ''` +
`${isEscaping ? ', __e = _.escape' : ''}` +
`${isEvaluating ? ', __j = Array.prototype.join;\nfunction print() { __p += __j.call(arguments, \'\') }\n' : ';\n'}` +
`${source} return __p;\n}`
const result = attempt(() => (
Function(importsKeys, `${sourceURL}return ${source}`))(...importsValues)
)
// Provide the compiled function's source by its `toString` method or
// the `source` property as a convenience for inlining compiled templates.
result.source = source
if (isError(result)) {
throw result
}
return result
}
export default template

65
templateSettings.js
View File

@@ -1,65 +0,0 @@
import escape from './escape.js'
import reEscape from './.internal/reEscape.js'
import reEvaluate from './.internal/reEvaluate.js'
import reInterpolate from './.internal/reInterpolate.js'
/**
* By default, the template delimiters used by lodash are like those in
* embedded Ruby (ERB) as well as ES2015 template strings. Change the
* following template settings to use alternative delimiters.
*
* @type {Object}
*/
const templateSettings = {
/**
* Used to detect `data` property values to be HTML-escaped.
*
* @memberOf templateSettings
* @type {RegExp}
*/
'escape': reEscape,
/**
* Used to detect code to be evaluated.
*
* @memberOf templateSettings
* @type {RegExp}
*/
'evaluate': reEvaluate,
/**
* Used to detect `data` property values to inject.
*
* @memberOf templateSettings
* @type {RegExp}
*/
'interpolate': reInterpolate,
/**
* Used to reference the data object in the template text.
*
* @memberOf templateSettings
* @type {string}
*/
'variable': '',
/**
* Used to import variables into the compiled template.
*
* @memberOf templateSettings
* @type {Object}
*/
'imports': {
/**
* A reference to the `lodash` function.
*
* @memberOf templateSettings.imports
* @type {Function}
*/
'_': { 'escape': escape }
}
}
export default templateSettings