package/package.json000644 000765 000024 0000002111 13134463307013014 0ustar00000000 000000 { "name": "value-or-function", "version": "3.0.0", "description": "Normalize a value or function, applying extra args to the function", "author": "Gulp Team (http://gulpjs.com/)", "contributors": [ "Blaine Bublitz ", "Hugo Wood " ], "repository": "gulpjs/value-or-function", "license": "MIT", "engines": { "node": ">= 0.10" }, "main": "index.js", "files": [ "index.js" ], "scripts": { "lint": "eslint . && jscs index.js test/", "pretest": "npm run lint", "test": "mocha --async-only", "cover": "istanbul cover node_modules/mocha/bin/_mocha --report lcovonly", "coveralls": "npm run cover && istanbul-coveralls" }, "dependencies": {}, "devDependencies": { "eslint": "^1.10.3", "eslint-config-gulp": "^2.0.0", "expect": "^1.16.0", "istanbul": "^0.4.3", "istanbul-coveralls": "^1.0.3", "jscs": "^2.3.5", "jscs-preset-gulp": "^1.0.0", "mocha": "^2.4.5" }, "keywords": [ "options", "normalize", "value", "function" ] } package/README.md000644 000765 000024 0000010411 13134463266012013 0ustar00000000 000000

# value-or-function [![NPM version][npm-image]][npm-url] [![Downloads][downloads-image]][npm-url] [![Build Status][travis-image]][travis-url] [![AppVeyor Build Status][appveyor-image]][appveyor-url] [![Coveralls Status][coveralls-image]][coveralls-url] [![Gitter chat][gitter-image]][gitter-url] Normalize a value or function, applying extra args to the function ## Example ```js var normalize = require('value-or-function'); // Values matching type are returned var isEnabled = normalize('boolean', true); // isEnabled === true // Values not matching type return undefined var isEnabled = normalize('boolean', 1); // isEnabled === undefined // Functions are called var isEnabled = normalize('boolean', function() { return false; }); // isEnabled === false // Extra arguments are applied to function var count = normalize('number', function(a, b) { return a + b; }, 1, 2); // count === 3 // Supply the function with context var context = { c: 3 }; var count = normalize.call(context, 'number', function(a, b) { return a + b + this.c; }, 1, 2); // count === 6 // Values one of multiple types are returned var isEnabled = normalize(['string', 'boolean'], true); // isEnabled === true // Provide a function as first argument to do custom coercion var now = new Date(); var enabledSince = normalize(function(value) { if (value.constructor === Date) { return value; } }, now); // enabledSince === now // Convenience methods are available for the built-in types var result = normalize.object({}); var result = normalize.number(1); var result = normalize.string(''); var result = normalize.symbol(Symbol()); var result = normalize.boolean(true); var result = normalize.function(function() {}); var result = normalize.date(new Date()); ``` ## API ### `normalize(coercer, value[, ...appliedArguments])` Takes a coercer function `coercer` to transform `value` to the desired type. Also optionally takes any extra arguments to apply to `value` if `value` is a function. If the return value of `coercer(value)` is not `null` or `undefined`, that value is returned. Otherwise, if `value` is a function, that function is called with any extra arguments supplied to `normalize`, and its return value is passed through the coercer. If `coercer` is a string, it must be one of the built-in types (see below) and the appropriate default coercer is invoked, optionally first reducing `value` to a primitive type with `.valueOf()` if it is an Object. If `coercer` is an array, each element is tried until one returns something other than `null` or `undefined`, or it results in `undefined` if all of the elements yield `null` or `undefined`. #### `normalize.object(value[, ...appliedArguments])` Convenience method for `normalize('object', ...)`. #### `normalize.number(value[, ...appliedArguments])` Convenience method for `normalize('number', ...)`. #### `normalize.string(value[, ...appliedArguments])` Convenience method for `normalize('string', ...)`. #### `normalize.symbol(value[, ...appliedArguments])` Convenience method for `normalize('symbol', ...)`. #### `normalize.boolean(value[, ...appliedArguments])` Convenience method for `normalize('boolean', ...)`. #### `normalize.function(value[, ...appliedArguments])` Convenience method for `normalize('function', ...)`. #### `normalize.date(value[, ...appliedArguments])` Convenience method for `normalize('date', ...)`. ## License MIT [downloads-image]: http://img.shields.io/npm/dm/value-or-function.svg [npm-url]: https://npmjs.org/package/value-or-function [npm-image]: http://img.shields.io/npm/v/value-or-function.svg [travis-url]: https://travis-ci.org/gulpjs/value-or-function [travis-image]: http://img.shields.io/travis/gulpjs/value-or-function.svg?label=travis-ci [appveyor-url]: https://ci.appveyor.com/project/gulpjs/value-or-function [appveyor-image]: https://img.shields.io/appveyor/ci/gulpjs/value-or-function.svg?label=appveyor [coveralls-url]: https://coveralls.io/r/gulpjs/value-or-function [coveralls-image]: http://img.shields.io/coveralls/gulpjs/value-or-function/master.svg [gitter-url]: https://gitter.im/gulpjs/gulp [gitter-image]: https://badges.gitter.im/gulpjs/gulp.png package/LICENSE000644 000765 000024 0000002142 12731403746011542 0ustar00000000 000000 The MIT License (MIT) Copyright (c) 2015 Blaine Bublitz, Eric Schoffstall and other contributors Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. package/index.js000644 000765 000024 0000004131 13134463266012203 0ustar00000000 000000 'use strict'; // Built-in types var types = [ 'object', 'number', 'string', 'symbol', 'boolean', 'date', 'function', // Weird to expose this ]; function normalize(coercer, value) { if (typeof value === 'function') { if (coercer === 'function') { return value; } value = value.apply(this, slice(arguments, 2)); } return coerce(this, coercer, value); } function coerce(ctx, coercer, value) { // Handle built-in types if (typeof coercer === 'string') { if (coerce[coercer]) { return coerce[coercer].call(ctx, value); } return typeOf(coercer, value); } // Handle custom coercer if (typeof coercer === 'function') { return coercer.call(ctx, value); } // Array of coercers, try in order until one returns a non-null value var result; coercer.some(function(coercer) { result = coerce(ctx, coercer, value); return result != null; }); return result; } coerce.string = function(value) { if (value != null && typeof value === 'object' && typeof value.toString === 'function') { value = value.toString(); } return typeOf('string', primitive(value)); }; coerce.number = function(value) { return typeOf('number', primitive(value)); }; coerce.boolean = function(value) { return typeOf('boolean', primitive(value)); }; coerce.date = function(value) { value = primitive(value); if (typeof value === 'number' && !isNaN(value) && isFinite(value)) { return new Date(value); } }; function typeOf(type, value) { if (typeof value === type) { return value; } } function primitive(value) { if (value != null && typeof value === 'object' && typeof value.valueOf === 'function') { value = value.valueOf(); } return value; } function slice(value, from) { return Array.prototype.slice.call(value, from); } // Add methods for each type types.forEach(function(type) { // Make it an array for easier concat var typeArg = [type]; normalize[type] = function() { var args = slice(arguments); return normalize.apply(this, typeArg.concat(args)); }; }); module.exports = normalize;