theluyuan/layui-js
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

clear

Browse Source
This commit is contained in:
sentsin
2017-08-21 08:50:25 +08:00
parent 06c11ba9cd
commit 7feaa4eca0
1899 changed files with 181363 additions and 22513 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
node_modules/deap/.npmignore generated vendored Normal file
View File

@@ -0,0 +1,16 @@
lib-cov
*.seed
*.log
*.csv
*.dat
*.out
*.pid
*.gz
pids
logs
results
npm-debug.log
/node_modules
/coverage

5
node_modules/deap/.travis.yml generated vendored Normal file
View File

@@ -0,0 +1,5 @@
language: node_js
node_js:
- "0.10"
after_script:
- npm run coveralls

22
node_modules/deap/LICENSE generated vendored Normal file
View File

@@ -0,0 +1,22 @@
(The MIT License)
Copyright (c) 2013 Brad Harris
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.

91
node_modules/deap/README.md generated vendored Normal file
View File

@@ -0,0 +1,91 @@
[![Build Status](https://travis-ci.org/selfcontained/deap.svg?branch=master)](https://travis-ci.org/selfcontained/deap)
[![Coverage Status](https://img.shields.io/coveralls/selfcontained/deap.svg)](https://coveralls.io/r/selfcontained/deap?branch=master)
===
[![browser support](https://ci.testling.com/selfcontained/deap.png)](http://ci.testling.com/selfcontained/deap)
deap
====
extend and merge objects, deep or shallow, in javascript
### installation
```bash
npm install deap
```
```javascript
var deap = require('deap');
```
### browser usage
**deap** assumes es5, so we recommend using an es5 shim for older browsers. [Browserify](https://github.com/substack/node-browserify) is also recommended as a means to use this module client-side, but other module loaders for browsers will work with **deap** as well if you shim it.
### available functions
+ deap() and deap.extend() - **deep extend**
+ deap.merge() - **deep merge**
+ deap.update() - **deep update**
+ deap.extendShallow() - **shallow extend**
+ deap.mergeShallow() - **shallow merge**
+ deap.updateShallow() - **shallow update**
+ deap.clone() - **deep clone**
---
### deap() and deap.extend()
Deep extend. Copy all the properties from one object onto another, cloning objects deeply.
Takes *n* number of arguments, modifies the first argument and returns it.
```javascript
var a = { name: 'Joe' };
deap.extend(a, { age: 26 }); // returns: a => { name: 'Joe', age: 26 }
deap.extend({}, someObj); // clone someObj
```
### deap.merge()
Deep merge. Copy properties from one object to another, not replacing existing properties.
Takes *n* number of arguments, modifies the first argument and returns it.
```javascript
var a = { name: 'Joe', address: { number: 1234 };
deap.merge(a, { name: 'Jack', age: 26, phone: '555-555-5555', address: { number: 4321, street: 'University Blvd' });
// returns: a => { name: 'Joe', age: 26, phone: '555-555-5555', address: { number: 1234, street: 'University Blvd' }}
```
### deap.update()
Deep update. Fill an object's existing properties from another object.
Takes *n* number of arguments, modifies the first argument and returns it.
```javascript
var a = { name: 'Joe', phone: '' };
deap.update(a, { age: 26, phone: '555-555-5555' }); // returns: a => { name: 'Joe', phone: '555-555-5555' }
```
---
## shallow only
If you prefer a shallow-only instance of **deap** you can require it specifically
```javascript
var deap = require('deap/shallow');
deap() && deap.extend(); // shallow extend
deap.merge(); //shallow merge
deap.update(); //shallow update
deap.clone(); // deep clone
```
... the end

14
node_modules/deap/index.js generated vendored Normal file
View File

@@ -0,0 +1,14 @@
var lib = require('./lib/deap');
var deap = module.exports = lib.extend;
deap(deap, {
clone: lib.clone,
extend: lib.extend,
update: lib.update,
merge: lib.merge,
cloneShallow: lib.cloneShallow,
extendShallow: lib.extendShallow,
updateShallow: lib.updateShallow,
mergeShallow: lib.mergeShallow
});

121
node_modules/deap/lib/deap.js generated vendored Normal file
View File

@@ -0,0 +1,121 @@
var typeOf = require('./typeof'),
slice = Array.prototype.slice;
module.exports = {
clone: deepClone,
cloneShallow: clone,
extend: deepExtend,
extendShallow: extend,
update: deepUpdate,
updateShallow: update,
merge: deepMerge,
mergeShallow: merge
};
function clone(val) {
switch(typeOf(val)) {
case 'object':
var args = slice.call(arguments);
args.unshift({});
return extend.apply(null, args);
case 'array':
return [].concat(val);
case 'date':
return new Date(val.getTime());
case 'regexp':
return new RegExp(val);
default:
return val;
}
}
function deepClone(val) {
switch(typeOf(val)) {
case 'object':
var args = slice.call(arguments);
args.unshift({});
return deepExtend.apply(null, args);
case 'array':
return val.map(function(v) { return deepClone(v); });
default:
return clone(val);
}
}
function extend(a, b /*, [b2..n] */) {
slice.call(arguments, 1).forEach(function(b) {
Object.keys(b).forEach(function(p) {
a[p] = b[p];
});
});
return a;
}
function deepExtend(a, b /*, [b2..n] */) {
slice.call(arguments, 1).forEach(function(b) {
Object.keys(b).forEach(function(p) {
if(typeOf(b[p]) === 'object' && typeOf(a[p]) === 'object')
deepExtend(a[p], b[p]);
else
a[p] = deepClone(b[p]);
});
});
return a;
}
function update(a, b /*, [b2..n] */) {
slice.call(arguments, 1).forEach(function(b) {
Object.keys(b).forEach(function(p) {
if(a.hasOwnProperty(p)) a[p] = b[p];
});
});
return a;
}
function deepUpdate(a, b /*, [b2..n] */) {
slice.call(arguments, 1).forEach(function(b) {
var ap, bp, ta, tb;
Object.keys(b).forEach(function(p) {
if(a.hasOwnProperty(p)) {
ap = a[p];
bp = b[p];
ta = typeOf(ap);
tb = typeOf(bp);
if(tb === 'object' && ta === 'object')
deepUpdate(ap, bp);
else if(tb === 'array' && ta === 'array') {
ap.length = 0;
ap.push.apply(ap, bp.map(function(v) { return deepClone(v); }));
} else
a[p] = deepClone(bp);
}
});
});
return a;
}
function merge(a, b /*, [b2..n] */) {
slice.call(arguments, 1).forEach(function(b) {
Object.keys(b).forEach(function(p) {
if(!a.hasOwnProperty(p)) a[p] = b[p];
});
});
return a;
}
function deepMerge(a, b /*, [b2..n] */) {
slice.call(arguments, 1).forEach(function(b) {
var ap, bp, ta, tb;
Object.keys(b).forEach(function(p) {
ap = a[p];
bp = b[p];
ta = typeOf(ap);
tb = typeOf(bp);
if(tb === 'object' && ta === 'object')
deepMerge(ap, bp);
else if(!a.hasOwnProperty(p))
a[p] = deepClone(bp);
});
});
return a;
}

19
node_modules/deap/lib/typeof.js generated vendored Normal file
View File

@@ -0,0 +1,19 @@
module.exports = function(obj) {
var t = typeof obj;
if(t !== 'object') return t;
// typeof null == 'object' so check seperately
if(obj === null) return 'null';
// typeof new Array|String|Number|Boolean|RegExp == 'object' so check seperately
switch(obj.constructor) {
case Array: return 'array';
case String: return 'string';
case Number: return 'number';
case Boolean: return 'boolean';
case RegExp: return 'regexp';
case Date: return 'date';
}
return 'object';
};

121
node_modules/deap/package.json generated vendored Normal file
View File

@@ -0,0 +1,121 @@
{
"_args": [
[
{
"raw": "deap@^1.0.0",
"scope": null,
"escapedName": "deap",
"name": "deap",
"rawSpec": "^1.0.0",
"spec": ">=1.0.0 <2.0.0",
"type": "range"
},
"D:\\web\\layui\\res\\layui\\node_modules\\gulp-uglify"
]
],
"_from": "deap@>=1.0.0 <2.0.0",
"_id": "deap@1.0.0",
"_inCache": true,
"_location": "/deap",
"_npmUser": {
"name": "bmharris",
"email": "bmharris@gmail.com"
},
"_npmVersion": "1.4.3",
"_phantomChildren": {},
"_requested": {
"raw": "deap@^1.0.0",
"scope": null,
"escapedName": "deap",
"name": "deap",
"rawSpec": "^1.0.0",
"spec": ">=1.0.0 <2.0.0",
"type": "range"
},
"_requiredBy": [
"/gulp-uglify"
],
"_resolved": "https://registry.npmjs.org/deap/-/deap-1.0.0.tgz",
"_shasum": "b148bf82430a27699b7483a03eb6b67585bfc888",
"_shrinkwrap": null,
"_spec": "deap@^1.0.0",
"_where": "D:\\web\\layui\\res\\layui\\node_modules\\gulp-uglify",
"author": {
"name": "Brad Harris",
"email": "bmharris@gmail.com",
"url": "http://selfcontained.us"
},
"bugs": {
"url": "https://github.com/selfcontained/deap/issues"
},
"contributors": [
{
"name": "Brad Harris",
"email": "bmharris@gmail.com",
"url": "http://selfcontained.us"
},
{
"name": "Matt Dunlap",
"url": "http://github.com/prestaul"
}
],
"dependencies": {},
"description": "extend and merge objects, deep or shallow",
"devDependencies": {
"chai": "~1.6.0",
"coveralls": "^2.10.0",
"istanbul": "^0.2.8",
"mocha": "~1.9.0"
},
"directories": {},
"dist": {
"shasum": "b148bf82430a27699b7483a03eb6b67585bfc888",
"tarball": "https://registry.npmjs.org/deap/-/deap-1.0.0.tgz"
},
"homepage": "https://github.com/selfcontained/deap",
"keywords": [
"extend",
"merge",
"mixin",
"deep",
"shallow",
"clone"
],
"license": "MIT",
"main": "index.js",
"maintainers": [
{
"name": "bmharris",
"email": "bmharris@gmail.com"
},
{
"name": "prestaul",
"email": "npm.prestaul@spamgourmet.com"
}
],
"name": "deap",
"optionalDependencies": {},
"readme": "ERROR: No README data found!",
"repository": {
"type": "git",
"url": "git://github.com/selfcontained/deap.git"
},
"scripts": {
"coverage": "istanbul cover --report html node_modules/.bin/_mocha",
"coveralls": "istanbul cover ./node_modules/mocha/bin/_mocha --report lcovonly -- && cat ./coverage/lcov.info | coveralls",
"test": "mocha test/*.test.js"
},
"testling": {
"browsers": [
"ie/9..latest",
"firefox/19..latest",
"chrome/25..latest",
"iphone/latest",
"ipad/latest",
"android-browser/latest"
],
"harness": "mocha-tdd",
"files": "test/*.test.js"
},
"version": "1.0.0"
}

10
node_modules/deap/shallow.js generated vendored Normal file
View File

@@ -0,0 +1,10 @@
var lib = require('./lib/deap');
var deap = module.exports = lib.extendShallow;
deap(deap, {
clone: lib.cloneShallow,
extend: lib.extendShallow,
update: lib.updateShallow,
merge: lib.mergeShallow
});

240
node_modules/deap/test/clone.test.js generated vendored Normal file
View File

@@ -0,0 +1,240 @@
var lib = require('../lib/deap'),
assert = require('chai').assert;
describe('shallow clone', function() {
var shallow = lib.cloneShallow;
it('should not return a reference to the first argument', function() {
var a = { burp: 'adurp' },
result = shallow(a);
assert.notStrictEqual(result, a);
});
it('should copy simple values', function() {
var a = { s: 'string', n: 1, b: false, a: [], o: {}},
b = shallow(a);
assert.deepEqual(b, a);
assert.equal(b.s, a.s);
assert.equal(b.n, a.n);
assert.equal(b.b, a.b);
assert.strictEqual(b.a, a.a);
assert.strictEqual(b.o, a.o);
});
it('should preserve object references', function() {
var deep = { foo: 'bar' },
a = { burp: 'adurp' , nested: deep },
result = shallow(a);
assert.strictEqual(result.nested, deep);
});
it('should preserve date references', function() {
var a = { burp: 'adurp', date: new Date() },
date = a.date;
var result = shallow(a);
assert.strictEqual(result.date, date);
});
it('should preserve regexp references', function() {
var a = { burp: 'adurp', regexp: /foo/g },
regexp = a.regexp;
var result = shallow(a);
assert.strictEqual(result.regexp, regexp);
});
it('should preserve array references', function() {
var a = { burp: 'adurp', array: [] },
array = a.array;
var result = shallow(a);
assert.strictEqual(result.array, array);
});
it('should clone Date objects', function() {
var a = new Date();
var result = shallow(a);
assert.equal(result.toString(), a.toString());
assert.notStrictEqual(result, a);
});
it('should clone RegExp objects', function() {
var a = /foo/;
var result = shallow(a);
assert.equal(result.toString(), a.toString());
assert.notStrictEqual(result, a);
});
it('should work for multiple arguments', function() {
var a = { doom: 'song' },
b = { burp: 'adurp' },
c = { grr: { doh: 'argh' } };
var result = shallow(a, b, c);
assert.deepEqual(a, { doom: 'song' });
assert.deepEqual(b, { burp: 'adurp' });
assert.deepEqual(c, { grr: { doh: 'argh' } });
assert.sameMembers(Object.keys(result), ['doom', 'burp', 'grr']);
assert.equal(result.doom, a.doom);
assert.equal(result.burp, b.burp);
assert.deepEqual(result.grr, c.grr);
assert.strictEqual(result.grr, c.grr);
});
describe('on an array', function() {
it('should preserve references', function() {
var a = ['string', 1, false, [], {}];
var result = shallow(a);
assert.deepEqual(result, a);
assert.equal(result[0], a[0]);
assert.equal(result[1], a[1]);
assert.equal(result[2], a[2]);
assert.strictEqual(result[3], a[3]);
assert.strictEqual(result[4], a[4]);
});
});
});
describe('clone', function() {
var clone = lib.clone;
it('should not return a reference to the first argument', function() {
var a = { burp: 'adurp' },
result = clone(a);
assert.notStrictEqual(result, a);
});
it('should copy simple values', function() {
var a = { s: 'string', n: 1, b: false, a: [], o: {}},
b = clone(a);
assert.deepEqual(b, a);
assert.equal(b.s, a.s);
assert.equal(b.n, a.n);
assert.equal(b.b, a.b);
assert.deepEqual(b.a, a.a);
assert.deepEqual(b.o, a.o);
});
it('should not preserve object references', function() {
var deeper = { boo: 'far' },
deep = { foo: 'bar', nested: deeper },
a = { burp: 'adurp' , nested: deep };
var result = clone(a);
assert.deepEqual(result, a);
assert.notStrictEqual(result.nested, deep);
assert.notStrictEqual(result.nested.nested, deeper);
});
it('should not preserve date references', function() {
var a = { burp: 'adurp', date: new Date() },
date = a.date;
var result = clone(a);
assert.deepEqual(result, a);
assert.equal(result.date.getTime(), date.getTime()); // added this because deepEqual doesn't work with dates
assert.notStrictEqual(result.date, date);
});
it('should not preserve regexp references', function() {
var a = { burp: 'adurp', regexp: /foo/g },
regexp = a.regexp;
var result = clone(a);
assert.deepEqual(result, a);
assert.notStrictEqual(result.regexp, regexp);
});
it('should not preserve array references', function() {
var deeper = { boo: 'far' },
deep = { foo: 'bar', nested: deeper },
a = { burp: 'adurp' , nested: [deep, deeper] };
var result = clone(a);
assert.deepEqual(result, a);
assert.notStrictEqual(result.nested, a.nested);
assert.notStrictEqual(result.nested[0], deep);
assert.notStrictEqual(result.nested[0].nested, deeper);
assert.notStrictEqual(result.nested[1], deeper);
assert.deepEqual(result.nested[0].nested, result.nested[1]);
assert.notStrictEqual(result.nested[0].nested, result.nested[1]);
});
it('should clone Date objects', function() {
var a = new Date();
var result = clone(a);
assert.equal(result.toString(), a.toString());
assert.notStrictEqual(result, a);
});
it('should clone RegExp objects', function() {
var a = /foo/;
var result = clone(a);
assert.equal(result.toString(), a.toString());
assert.notStrictEqual(result, a);
});
it('should work for multiple arguments', function() {
var a = { doom: 'song' },
b = { burp: 'adurp' },
c = { grr: { doh: 'argh' } };
var result = clone(a, b, c);
assert.deepEqual(a, { doom: 'song' });
assert.deepEqual(b, { burp: 'adurp' });
assert.deepEqual(c, { grr: { doh: 'argh' } });
assert.sameMembers(Object.keys(result), ['doom', 'burp', 'grr']);
assert.equal(result.doom, a.doom);
assert.equal(result.burp, b.burp);
assert.deepEqual(result.grr, c.grr);
assert.notStrictEqual(result.grr, c.grr);
});
describe('on an array', function() {
it('should not preserve references', function() {
var a = ['string', 1, false, [], {}];
var result = clone(a);
assert.deepEqual(result, a);
assert.equal(result[0], a[0]);
assert.equal(result[1], a[1]);
assert.equal(result[2], a[2]);
assert.notStrictEqual(result[3], a[3]);
assert.notStrictEqual(result[4], a[4]);
});
});
});

53
node_modules/deap/test/deap.test.js generated vendored Normal file
View File

@@ -0,0 +1,53 @@
var assert = require('chai').assert,
deap = require('../index'),
lib = require('../lib/deap');
describe('deap', function() {
it('should have clone defined', function() {
assert.isFunction(deap.clone);
assert.deepEqual(deap.clone, lib.clone);
});
it('should have cloneShallow defined', function() {
assert.isFunction(deap.cloneShallow);
assert.deepEqual(deap.cloneShallow, lib.cloneShallow);
});
it('should have extend exposed as a top level function', function() {
assert.isFunction(deap);
assert.equal(deap, lib.extend);
});
it('should have extend defined', function() {
assert.isFunction(deap.extend);
assert.deepEqual(deap.extend, lib.extend);
});
it('should have extendShallow defined', function() {
assert.isFunction(deap.extendShallow);
assert.deepEqual(deap.extendShallow, lib.extendShallow);
});
it('should have update defined', function() {
assert.isFunction(deap.update);
assert.deepEqual(deap.update, lib.update);
});
it('should have updateShallow defined', function() {
assert.isFunction(deap.updateShallow);
assert.deepEqual(deap.updateShallow, lib.updateShallow);
});
it('should have merge defined', function() {
assert.isFunction(deap.merge);
assert.deepEqual(deap.merge, lib.merge);
});
it('should have mergeShallow defined', function() {
assert.isFunction(deap.mergeShallow);
assert.deepEqual(deap.mergeShallow, lib.mergeShallow);
});
});

155
node_modules/deap/test/extend.test.js generated vendored Normal file
View File

@@ -0,0 +1,155 @@
var assert = require('chai').assert,
lib = require('../lib/deap');
describe('shallow extend', function() {
var shallow = lib.extendShallow;
it('should return a reference to the first argument', function() {
var a = { burp: 'adurp' },
b = { burp: 'zing', grr: 'arghh' };
var result = shallow(a, b);
assert.strictEqual(result, a);
});
it('should copy simple values', function() {
var a = {},
b = { s: 'string', n: 1, b: false, a: [], o: {}};
var c = shallow(a, b);
assert.deepEqual(c, a);
assert.equal(c.s, b.s);
assert.equal(c.n, b.n);
assert.equal(c.b, b.b);
assert.strictEqual(c.a, b.a);
assert.strictEqual(c.o, b.o);
});
it('should only alter first param', function() {
var a = { doom: 'song' },
b = { burp: 'adurp' },
c = { grr: 'argh' };
var result = shallow({}, a, b, c);
assert.deepEqual(a, { doom: 'song' });
assert.deepEqual(b, { burp: 'adurp' });
assert.deepEqual(c, { grr: 'argh' });
assert.sameMembers(Object.keys(result), ['doom', 'burp', 'grr']);
assert.equal(result.doom, a.doom);
assert.equal(result.burp, b.burp);
assert.equal(result.grr, c.grr);
});
it('should preserve object references', function() {
var deep = { foo: 'bar' },
a = { burp: 'adurp' , nested: deep };
var result = shallow({}, a);
assert.strictEqual(result.nested, deep);
});
it('should preserve date references', function() {
var a = { burp: 'adurp', date: new Date() },
date = a.date;
var result = shallow({}, a);
assert.strictEqual(result.date, date);
});
it('should preserve regexp references', function() {
var a = { burp: 'adurp', regexp: /foo/g },
regexp = a.regexp;
var result = shallow({}, a);
assert.strictEqual(result.regexp, regexp);
});
it('should preserve array references', function() {
var a = { burp: 'adurp', array: [] },
array = a.array;
var result = shallow({}, a);
assert.strictEqual(result.array, array);
});
it('should not pick up non-enumberable properties', function() {
var result = shallow({}, function() {});
assert.deepEqual(result, {});
assert.equal(Object.keys(result).length, 0);
assert.equal(Object.getOwnPropertyNames(result).length, 0);
});
});
describe('deep extend', function() {
var deepExtend = lib.extend;
it('should return a reference to the first argument', function() {
var a = { burp: 'adurp' },
b = { burp: 'zing', grr: 'arghh' };
var result = deepExtend(a, b);
assert.strictEqual(result, a);
});
it('should not preserve object references', function() {
var deeper = { boo: 'far' },
deep = { foo: 'bar', nested: deeper },
a = { burp: 'adurp' , nested: deep };
var result = deepExtend({}, a);
assert.deepEqual(result, a);
assert.notStrictEqual(result.nested, deep);
assert.notStrictEqual(result.nested.nested, deeper);
});
it('should not preserve date references', function() {
var a = { burp: 'adurp', date: new Date() },
date = a.date;
var result = deepExtend({}, a);
assert.deepEqual(result, a);
assert.equal(result.date.getTime(), date.getTime()); // added this because deepEqual doesn't work with dates
assert.notStrictEqual(result.date, date);
});
it('should not preserve regexp references', function() {
var a = { burp: 'adurp', regexp: /foo/g },
regexp = a.regexp;
var result = deepExtend({}, a);
assert.deepEqual(result, a);
assert.notStrictEqual(result.regexp, regexp);
});
it('should not preserve array references', function() {
var deeper = { boo: 'far' },
deep = { foo: 'bar', nested: deeper },
a = { burp: 'adurp' , nested: [deep, deeper] };
var result = deepExtend({}, a);
assert.deepEqual(result, a);
assert.notStrictEqual(result.nested, a.nested);
assert.notStrictEqual(result.nested[0], deep);
assert.notStrictEqual(result.nested[0].nested, deeper);
assert.notStrictEqual(result.nested[1], deeper);
assert.deepEqual(result.nested[0].nested, result.nested[1]);
assert.notStrictEqual(result.nested[0].nested, result.nested[1]);
});
});

134
node_modules/deap/test/merge.test.js generated vendored Normal file
View File

@@ -0,0 +1,134 @@
var lib = require('../lib/deap'),
assert = require('chai').assert;
describe('shallow merge', function() {
var shallowMerge = lib.mergeShallow;
it('should merge everything into an empty object', function() {
var a = { foo: 'bar' },
result = shallowMerge({}, a);
assert.deepEqual(result, a);
});
it('should return a reference to the first argument', function() {
var a = { burp: 'adurp' },
b = { burp: 'zing', grr: 'arghh' };
var result = shallowMerge(a, b);
assert.strictEqual(result, a);
});
it('should not replace existing values', function() {
var a = { burp: 'adurp' },
b = { burp: 'zing', grr: 'arghh' };
var result = shallowMerge(a, b);
assert.deepEqual(result, { burp: 'adurp', grr: 'arghh' });
assert.equal(result.burp, a.burp);
});
});
describe('deep merge', function() {
var deepMerge = lib.merge;
it('should return a reference to the first argument', function() {
var a = { burp: 'adurp' },
b = { burp: 'zing', grr: 'arghh' };
var result = deepMerge(a, b);
assert.strictEqual(result, a);
});
it('should merge a nested object one level deep', function() {
var a = { foo: 'bar', deep: { foo: 'bar', baz: 'buzz' }},
b = { foo: 'bop', deep: { foo: 'beep', biz: 'baz' } };
var result = deepMerge(a, b);
assert.equal(result.foo, 'bar');
assert.equal(result.deep.foo, 'bar');
assert.equal(result.deep.baz, 'buzz');
assert.equal(result.deep.biz, 'baz');
});
it('should merge a nested object two levels deep', function() {
var a = { foo: 'bar', deep: { hi: 'hello', deeper: { foo: 'bar', baz: 'buzz' }}},
b = { foo: 'baz', deep: { hi: 'bye', bye: 'hi', deeper: { foo: 'beep', bop: 'boop' } } };
var result = deepMerge({}, a, b);
assert.equal(result.foo, a.foo);
assert.isObject(result.deep);
assert.equal(result.deep.hi, a.deep.hi);
assert.equal(result.deep.bye, b.deep.bye);
assert.isObject(result.deep.deeper);
assert.equal(result.deep.deeper.foo, a.deep.deeper.foo);
assert.equal(result.deep.deeper.baz, a.deep.deeper.baz);
assert.equal(result.deep.deeper.bop, b.deep.deeper.bop);
});
it('should merge properties from multiple objects', function() {
var a = { foo: ['one'], boo: 'far', poo: 'tar' },
b = { foo: ['two', 'three'], zoo: 'car' },
c = { boo: 'star', two: 'czar' };
var result = deepMerge({}, a, b, c);
assert.deepEqual(result, {
foo: a.foo,
boo: a.boo,
poo: a.poo,
zoo: b.zoo,
two: c.two
});
});
it('should not preserve nested object references', function() {
var a = { foo: 'bar' },
nested = { grr: 'argh' },
newFoo = { burp: nested },
b = { foo: newFoo, foo2: newFoo };
var result = deepMerge(a, b);
assert.equal(a.foo, 'bar');
assert.deepEqual(a.foo2.burp, b.foo2.burp);
assert.notStrictEqual(a.foo2.burp, nested);
});
it('should not override a string with an object', function() {
var a = { foo: 'bar' },
b = { foo: { biz: 'baz' } };
var result = deepMerge(a, b);
assert.deepEqual(a, { foo: 'bar' });
});
it('should preserve array references', function() {
var a = { nested: [{ foo: 'bar' }] },
b = { nested: [{ boo: 'far' }] },
deep = a.nested;
var result = deepMerge(a, b);
assert.deepEqual(result.nested, a.nested);
assert.notStrictEqual(result.nested, b.nested);
assert.strictEqual(result.nested, deep);
});
it('should not preserve references in arrays', function() {
var a = { nested: [{ foo: 'bar' }] },
b = { nested: [{ boo: 'far' }] },
deeper = a.nested[0];
var result = deepMerge({}, a, b);
assert.deepEqual(result.nested, a.nested);
assert.notStrictEqual(result.nested[0], deeper);
});
});

24
node_modules/deap/test/shallow.test.js generated vendored Normal file
View File

@@ -0,0 +1,24 @@
var assert = require('chai').assert,
lib = require('../lib/deap'),
shallow = require('../shallow');
describe('shallow', function() {
it('should be defined correctly', function() {
assert.isFunction(shallow);
assert.isFunction(shallow.extend);
assert.isFunction(shallow.update);
assert.isFunction(shallow.merge);
assert.isFunction(shallow.clone);
});
it('should have shallow functions', function() {
assert.equal(shallow, lib.extendShallow);
assert.equal(shallow.extend, lib.extendShallow);
assert.equal(shallow.update, lib.updateShallow);
assert.equal(shallow.merge, lib.mergeShallow);
assert.equal(shallow.clone, lib.cloneShallow);
});
});

136
node_modules/deap/test/update.test.js generated vendored Normal file
View File

@@ -0,0 +1,136 @@
var lib = require('../lib/deap'),
assert = require('chai').assert;
describe('shallow update', function() {
var shallowUpdate = lib.updateShallow;
it('should not update anything into an empty object', function() {
var result = shallowUpdate({}, { foo: 'bar' });
assert.deepEqual(result, {});
});
it('should return a reference to the first argument', function() {
var a = { burp: 'adurp' },
b = { burp: 'zing', grr: 'arghh' };
var result = shallowUpdate(a, b);
assert.strictEqual(result, a);
});
it('should replace existing values only', function() {
var a = { burp: 'adurp' },
b = { burp: 'zing', grr: 'arghh' };
var result = shallowUpdate(a, b);
assert.deepEqual(result, a);
assert.equal(a.burp, b.burp);
assert.isUndefined(a.grr);
});
});
describe('deep update', function() {
var deepUpdate = lib.update;
it('should return a reference to the first argument', function() {
var a = { burp: 'adurp' },
b = { burp: 'zing', grr: 'arghh' };
var result = deepUpdate(a, b);
assert.strictEqual(result, a);
});
it('should update a nested object one level deep', function() {
var a = { foo: 'bar', deep: { foo: 'bar', baz: 'buzz' }},
b = { deep: { foo: 'beep' } };
var result = deepUpdate(a, b);
assert.equal(result.foo, a.foo);
assert.equal(result.deep.foo, b.deep.foo);
assert.equal(result.deep.baz, a.deep.baz);
});
it('should update a nested object two levels deep', function() {
var a = { foo: 'bar', deep: { hi: 'hello', deeper: { foo: 'bar', baz: 'buzz' }}},
b = { deep: { deeper: { foo: 'beep' } } };
var result = deepUpdate(a, b);
assert.equal(result.foo, a.foo);
assert.isObject(result.deep);
assert.equal(result.deep.hi, a.deep.hi);
assert.isObject(result.deep.deeper);
assert.equal(result.deep.deeper.foo, b.deep.deeper.foo);
assert.equal(result.deep.deeper.baz, a.deep.deeper.baz);
});
it('should update properties from multiple objects', function() {
var a = { foo: ['one'], boo: 'far', poo: 'tar' },
b = { foo: ['two', 'three'], zoo: 'car' },
c = { boo: 'star', two: 'czar' };
var result = deepUpdate(a, b, c);
assert.deepEqual(result, {
foo: b.foo,
boo: c.boo,
poo: a.poo
});
});
it('should not update properties that are not on the first argument', function() {
var a = { foo: 'bar', deep: { deeper: { foo: 'bar' } } },
b = { boo: 'far', deep: { hi: 'hello', deeper: { foo: 'beep', baz: 'buzz' } } };
var result = deepUpdate(a, b);
assert.isUndefined(result.boo);
assert.isObject(result.deep);
assert.isUndefined(result.deep.hi);
assert.isObject(result.deep.deeper);
assert.isUndefined(result.deep.deeper.baz);
assert.equal(result.deep.deeper.foo, b.deep.deeper.foo);
});
it('should not preserve nested object references', function() {
var a = { foo: 'bar' },
nested = { grr: 'argh' },
newFoo = { burp: nested },
b = { foo: newFoo };
var result = deepUpdate(a, b);
assert.deepEqual(a.foo.burp, b.foo.burp);
assert.notStrictEqual(a.foo.burp, nested);
});
it('should preserve array references', function() {
var a = { nested: [{ foo: 'bar' }] },
b = { nested: [{ boo: 'far' }] },
deep = a.nested;
var result = deepUpdate(a, b);
assert.deepEqual(result.nested, b.nested);
assert.notStrictEqual(result.nested, b.nested);
assert.strictEqual(result.nested, a.nested);
assert.strictEqual(result.nested, deep);
});
it('should not preserve references in arrays', function() {
var a = { nested: [{ foo: 'bar' }] },
b = { nested: [{ boo: 'far' }] },
deeper = a.nested[0];
var result = deepUpdate(a, b);
assert.deepEqual(result.nested, b.nested);
assert.notStrictEqual(result.nested[0], deeper);
});
});