Skip to content

Commit da8d5a9

Browse files
yeikosyeikos
committedJul 28, 2019
build: compiled sources
·
v2.1.1v2.1.0
1 parent f3e2133 commit da8d5a9

7 files changed

+512
-0
lines changed
 

‎dist/merge.browser.min.js

+1
Some generated files are not rendered by default. Learn more about customizing how changed files appear on GitHub.

‎dist/merge.browser.test.html

+22
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,22 @@
1+
<!DOCTYPE html>
2+
<html lang="en">
3+
<head>
4+
<meta charset="utf-8" />
5+
<title>Mocha Tests</title>
6+
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
7+
<link rel="stylesheet" href="../node_modules/mocha/mocha.css" />
8+
</head>
9+
<body>
10+
<div id="mocha"></div>
11+
<script src="../node_modules/chai/chai.js"></script>
12+
<script src="../node_modules/mocha/mocha.js"></script>
13+
<script class="mocha-init">
14+
mocha.setup('bdd');
15+
mocha.checkLeaks();
16+
</script>
17+
<script src="./merge.browser.test.js"></script>
18+
<script class="mocha-exec">
19+
mocha.run();
20+
</script>
21+
</body>
22+
</html>

‎dist/merge.browser.test.js

+288
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,288 @@
1+
/******/ (function(modules) { // webpackBootstrap
2+
/******/ // The module cache
3+
/******/ var installedModules = {};
4+
/******/
5+
/******/ // The require function
6+
/******/ function __webpack_require__(moduleId) {
7+
/******/
8+
/******/ // Check if module is in cache
9+
/******/ if(installedModules[moduleId]) {
10+
/******/ return installedModules[moduleId].exports;
11+
/******/ }
12+
/******/ // Create a new module (and put it into the cache)
13+
/******/ var module = installedModules[moduleId] = {
14+
/******/ i: moduleId,
15+
/******/ l: false,
16+
/******/ exports: {}
17+
/******/ };
18+
/******/
19+
/******/ // Execute the module function
20+
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
21+
/******/
22+
/******/ // Flag the module as loaded
23+
/******/ module.l = true;
24+
/******/
25+
/******/ // Return the exports of the module
26+
/******/ return module.exports;
27+
/******/ }
28+
/******/
29+
/******/
30+
/******/ // expose the modules object (__webpack_modules__)
31+
/******/ __webpack_require__.m = modules;
32+
/******/
33+
/******/ // expose the module cache
34+
/******/ __webpack_require__.c = installedModules;
35+
/******/
36+
/******/ // define getter function for harmony exports
37+
/******/ __webpack_require__.d = function(exports, name, getter) {
38+
/******/ if(!__webpack_require__.o(exports, name)) {
39+
/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter });
40+
/******/ }
41+
/******/ };
42+
/******/
43+
/******/ // define __esModule on exports
44+
/******/ __webpack_require__.r = function(exports) {
45+
/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
46+
/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
47+
/******/ }
48+
/******/ Object.defineProperty(exports, '__esModule', { value: true });
49+
/******/ };
50+
/******/
51+
/******/ // create a fake namespace object
52+
/******/ // mode & 1: value is a module id, require it
53+
/******/ // mode & 2: merge all properties of value into the ns
54+
/******/ // mode & 4: return value when already ns object
55+
/******/ // mode & 8|1: behave like require
56+
/******/ __webpack_require__.t = function(value, mode) {
57+
/******/ if(mode & 1) value = __webpack_require__(value);
58+
/******/ if(mode & 8) return value;
59+
/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
60+
/******/ var ns = Object.create(null);
61+
/******/ __webpack_require__.r(ns);
62+
/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value });
63+
/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
64+
/******/ return ns;
65+
/******/ };
66+
/******/
67+
/******/ // getDefaultExport function for compatibility with non-harmony modules
68+
/******/ __webpack_require__.n = function(module) {
69+
/******/ var getter = module && module.__esModule ?
70+
/******/ function getDefault() { return module['default']; } :
71+
/******/ function getModuleExports() { return module; };
72+
/******/ __webpack_require__.d(getter, 'a', getter);
73+
/******/ return getter;
74+
/******/ };
75+
/******/
76+
/******/ // Object.prototype.hasOwnProperty.call
77+
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
78+
/******/
79+
/******/ // __webpack_public_path__
80+
/******/ __webpack_require__.p = "";
81+
/******/
82+
/******/
83+
/******/ // Load entry module and return exports
84+
/******/ return __webpack_require__(__webpack_require__.s = 0);
85+
/******/ })
86+
/************************************************************************/
87+
/******/ ([
88+
/* 0 */
89+
/***/ (function(module, exports, __webpack_require__) {
90+
91+
"use strict";
92+
93+
Object.defineProperty(exports, "__esModule", { value: true });
94+
var chai_1 = __webpack_require__(1);
95+
var index_1 = __webpack_require__(2);
96+
describe('merge', function () {
97+
it('basic', function () {
98+
chai_1.assert.deepEqual(index_1.default({ a: 1 }, { b: 2 }), { a: 1, b: 2 });
99+
chai_1.assert.deepEqual(index_1.default({ a: 1 }, { b: { c: { d: 2 } } }), { a: 1, b: { c: { d: 2 } } });
100+
});
101+
it('clone', function () {
102+
var input = {
103+
a: 1,
104+
b: {
105+
c: {
106+
d: 2,
107+
e: ['x', 'y', { z: { w: ['k'] } }]
108+
}
109+
},
110+
f: null,
111+
g: undefined,
112+
h: true
113+
};
114+
var original = {
115+
a: 1,
116+
b: {
117+
c: {
118+
d: 2,
119+
e: ['x', 'y', { z: { w: ['k'] } }]
120+
}
121+
},
122+
f: null,
123+
g: undefined,
124+
h: true
125+
};
126+
var output = index_1.default(true, input);
127+
input.b.c.d++;
128+
input.b.c.e[2].z.w = null;
129+
input.h = null;
130+
chai_1.assert.deepEqual(original, output);
131+
input = original;
132+
output = index_1.default(true, input, { a: 2 });
133+
chai_1.assert.deepEqual(output.a, 2);
134+
chai_1.assert.deepEqual(input.a, 1);
135+
});
136+
it('invalid input', function () {
137+
chai_1.assert.deepEqual(index_1.default(), {});
138+
chai_1.assert.deepEqual(index_1.default(undefined), {});
139+
chai_1.assert.deepEqual(index_1.default([]), {});
140+
chai_1.assert.deepEqual(index_1.default(true), {});
141+
chai_1.assert.deepEqual(index_1.default(null, true, [0, 1, 2], 3, { a: 1 }, function () { }, undefined, { b: 2 }), { a: 1, b: 2 });
142+
});
143+
it('prototype pollution attack', function () {
144+
chai_1.assert.deepEqual(index_1.default({}, JSON.parse('{"__proto__": {"a": true}}')), {});
145+
});
146+
});
147+
describe('merge.clone', function () {
148+
it('object', function () {
149+
var object1 = { a: 1, b: { c: 2 } };
150+
var object2 = index_1.default.clone(object1);
151+
chai_1.assert.deepEqual(object1, object2);
152+
chai_1.assert.deepEqual(object1 === object2, false);
153+
chai_1.assert.deepEqual(object1.b === object2.b, false);
154+
});
155+
it('array', function () {
156+
var object1 = [{ a: 1, b: { c: 2 } }];
157+
var object2 = index_1.default.clone(object1);
158+
chai_1.assert.deepEqual(object1, object2);
159+
chai_1.assert.deepEqual(object1 === object2, false);
160+
chai_1.assert.deepEqual(object1[0] === object2[0], false);
161+
chai_1.assert.deepEqual(object1[0].b === object2[0].b, false);
162+
});
163+
it('invalid input', function () {
164+
chai_1.assert.deepEqual(index_1.default.clone(null), null);
165+
chai_1.assert.deepEqual(index_1.default.clone(undefined), undefined);
166+
chai_1.assert.deepEqual(index_1.default.clone(1), 1);
167+
chai_1.assert.deepEqual(index_1.default.clone('str'), 'str');
168+
});
169+
});
170+
describe('merge.recursive', function () {
171+
it('basic', function () {
172+
chai_1.assert.deepEqual(index_1.default.recursive({ a: { b: 1 } }, { a: { c: 1 } }), { a: { b: 1, c: 1 } });
173+
chai_1.assert.deepEqual(index_1.default.recursive({ a: { b: 1, c: 1 } }, { a: { b: 2 } }), { a: { b: 2, c: 1 } });
174+
chai_1.assert.deepEqual(index_1.default.recursive({ a: { b: [1, 2, 3], c: 1 } }, { a: { b: ['a'] } }), { a: { b: ['a'], c: 1 } });
175+
chai_1.assert.deepEqual(index_1.default.recursive({ a: { b: { b: 2 }, c: 1 } }, { a: { b: 2 } }), { a: { b: 2, c: 1 } });
176+
});
177+
it('clone', function () {
178+
var test1 = { a: { b: 1 } };
179+
chai_1.assert.deepEqual(index_1.default.recursive(true, test1, { a: { c: 1 } }), { a: { b: 1, c: 1 } });
180+
chai_1.assert.deepEqual({ a: { b: 1 } }, test1);
181+
var test2 = { a: { b: 1, c: 1 } };
182+
chai_1.assert.deepEqual(index_1.default.recursive(true, test2, { a: { b: 2 } }), { a: { b: 2, c: 1 } });
183+
chai_1.assert.deepEqual({ a: { b: 1, c: 1 } }, test2);
184+
var test3 = { a: { b: [1, 2, 3], c: 1 } };
185+
chai_1.assert.deepEqual(index_1.default.recursive(true, test3, { a: { b: ['a'] } }), { a: { b: ['a'], c: 1 } });
186+
chai_1.assert.deepEqual({ a: { b: [1, 2, 3], c: 1 } }, test3);
187+
var test4 = { a: { b: { b: 2 }, c: 1 } };
188+
chai_1.assert.deepEqual(index_1.default.recursive(true, test4, { a: { b: 2 } }), { a: { b: 2, c: 1 } });
189+
chai_1.assert.deepEqual({ a: { b: { b: 2 }, c: 1 } }, test4);
190+
});
191+
it('prototype pollution attack', function () {
192+
chai_1.assert.deepEqual(index_1.default.recursive({}, JSON.parse('{"__proto__": {"a": true}}')), {});
193+
});
194+
});
195+
196+
197+
/***/ }),
198+
/* 1 */
199+
/***/ (function(module, exports) {
200+
201+
module.exports = chai;
202+
203+
/***/ }),
204+
/* 2 */
205+
/***/ (function(module, exports, __webpack_require__) {
206+
207+
"use strict";
208+
209+
Object.defineProperty(exports, "__esModule", { value: true });
210+
function main() {
211+
var items = [];
212+
for (var _i = 0; _i < arguments.length; _i++) {
213+
items[_i] = arguments[_i];
214+
}
215+
return merge.apply(void 0, items);
216+
}
217+
exports.default = main;
218+
main.clone = clone;
219+
main.isPlainObject = isPlainObject;
220+
main.recursive = recursive;
221+
function merge() {
222+
var items = [];
223+
for (var _i = 0; _i < arguments.length; _i++) {
224+
items[_i] = arguments[_i];
225+
}
226+
return _merge(items[0] === true, false, items);
227+
}
228+
exports.merge = merge;
229+
function recursive() {
230+
var items = [];
231+
for (var _i = 0; _i < arguments.length; _i++) {
232+
items[_i] = arguments[_i];
233+
}
234+
return _merge(items[0] === true, true, items);
235+
}
236+
exports.recursive = recursive;
237+
function clone(input) {
238+
if (Array.isArray(input)) {
239+
var output = [];
240+
for (var index = 0; index < input.length; ++index)
241+
output.push(clone(input[index]));
242+
return output;
243+
}
244+
else if (isPlainObject(input)) {
245+
var output = {};
246+
for (var index in input)
247+
output[index] = clone(input[index]);
248+
return output;
249+
}
250+
else {
251+
return input;
252+
}
253+
}
254+
exports.clone = clone;
255+
function isPlainObject(input) {
256+
return input && typeof input === 'object' && !Array.isArray(input);
257+
}
258+
exports.isPlainObject = isPlainObject;
259+
function _recursiveMerge(base, extend) {
260+
if (!isPlainObject(base))
261+
return extend;
262+
for (var key in extend)
263+
base[key] = (isPlainObject(base[key]) && isPlainObject(extend[key])) ?
264+
_recursiveMerge(base[key], extend[key]) :
265+
extend[key];
266+
return base;
267+
}
268+
function _merge(isClone, isRecursive, items) {
269+
var result;
270+
if (isClone || !isPlainObject(result = items.shift()))
271+
result = {};
272+
for (var index = 0; index < items.length; ++index) {
273+
var item = items[index];
274+
if (!isPlainObject(item))
275+
continue;
276+
for (var key in item) {
277+
if (key === '__proto__')
278+
continue;
279+
var value = isClone ? clone(item[key]) : item[key];
280+
result[key] = isRecursive ? _recursiveMerge(result[key], value) : value;
281+
}
282+
}
283+
return result;
284+
}
285+
286+
287+
/***/ })
288+
/******/ ]);

‎lib/src/index.d.ts

+20
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,20 @@
1+
declare function main(clone: boolean, ...items: any[]): any;
2+
declare namespace main {
3+
var clone: typeof import(".").clone;
4+
var isPlainObject: typeof import(".").isPlainObject;
5+
var recursive: typeof import(".").recursive;
6+
}
7+
export default main;
8+
declare function main(...items: any[]): any;
9+
declare namespace main {
10+
var clone: typeof import(".").clone;
11+
var isPlainObject: typeof import(".").isPlainObject;
12+
var recursive: typeof import(".").recursive;
13+
}
14+
export default main;
15+
export declare function merge(clone: boolean, ...items: any[]): any;
16+
export declare function merge(...items: any[]): any;
17+
export declare function recursive(clone: boolean, ...items: any[]): any;
18+
export declare function recursive(...items: any[]): any;
19+
export declare function clone<T>(input: T): T;
20+
export declare function isPlainObject(input: any): input is Object;

‎lib/src/index.js

+77
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,77 @@
1+
"use strict";
2+
Object.defineProperty(exports, "__esModule", { value: true });
3+
function main() {
4+
var items = [];
5+
for (var _i = 0; _i < arguments.length; _i++) {
6+
items[_i] = arguments[_i];
7+
}
8+
return merge.apply(void 0, items);
9+
}
10+
exports.default = main;
11+
main.clone = clone;
12+
main.isPlainObject = isPlainObject;
13+
main.recursive = recursive;
14+
function merge() {
15+
var items = [];
16+
for (var _i = 0; _i < arguments.length; _i++) {
17+
items[_i] = arguments[_i];
18+
}
19+
return _merge(items[0] === true, false, items);
20+
}
21+
exports.merge = merge;
22+
function recursive() {
23+
var items = [];
24+
for (var _i = 0; _i < arguments.length; _i++) {
25+
items[_i] = arguments[_i];
26+
}
27+
return _merge(items[0] === true, true, items);
28+
}
29+
exports.recursive = recursive;
30+
function clone(input) {
31+
if (Array.isArray(input)) {
32+
var output = [];
33+
for (var index = 0; index < input.length; ++index)
34+
output.push(clone(input[index]));
35+
return output;
36+
}
37+
else if (isPlainObject(input)) {
38+
var output = {};
39+
for (var index in input)
40+
output[index] = clone(input[index]);
41+
return output;
42+
}
43+
else {
44+
return input;
45+
}
46+
}
47+
exports.clone = clone;
48+
function isPlainObject(input) {
49+
return input && typeof input === 'object' && !Array.isArray(input);
50+
}
51+
exports.isPlainObject = isPlainObject;
52+
function _recursiveMerge(base, extend) {
53+
if (!isPlainObject(base))
54+
return extend;
55+
for (var key in extend)
56+
base[key] = (isPlainObject(base[key]) && isPlainObject(extend[key])) ?
57+
_recursiveMerge(base[key], extend[key]) :
58+
extend[key];
59+
return base;
60+
}
61+
function _merge(isClone, isRecursive, items) {
62+
var result;
63+
if (isClone || !isPlainObject(result = items.shift()))
64+
result = {};
65+
for (var index = 0; index < items.length; ++index) {
66+
var item = items[index];
67+
if (!isPlainObject(item))
68+
continue;
69+
for (var key in item) {
70+
if (key === '__proto__')
71+
continue;
72+
var value = isClone ? clone(item[key]) : item[key];
73+
result[key] = isRecursive ? _recursiveMerge(result[key], value) : value;
74+
}
75+
}
76+
return result;
77+
}

‎lib/test/index.d.ts

+1
Original file line numberDiff line numberDiff line change
@@ -0,0 +1 @@
1+
export {};

‎lib/test/index.js

+103
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,103 @@
1+
"use strict";
2+
Object.defineProperty(exports, "__esModule", { value: true });
3+
var chai_1 = require("chai");
4+
var index_1 = require("../src/index");
5+
describe('merge', function () {
6+
it('basic', function () {
7+
chai_1.assert.deepEqual(index_1.default({ a: 1 }, { b: 2 }), { a: 1, b: 2 });
8+
chai_1.assert.deepEqual(index_1.default({ a: 1 }, { b: { c: { d: 2 } } }), { a: 1, b: { c: { d: 2 } } });
9+
});
10+
it('clone', function () {
11+
var input = {
12+
a: 1,
13+
b: {
14+
c: {
15+
d: 2,
16+
e: ['x', 'y', { z: { w: ['k'] } }]
17+
}
18+
},
19+
f: null,
20+
g: undefined,
21+
h: true
22+
};
23+
var original = {
24+
a: 1,
25+
b: {
26+
c: {
27+
d: 2,
28+
e: ['x', 'y', { z: { w: ['k'] } }]
29+
}
30+
},
31+
f: null,
32+
g: undefined,
33+
h: true
34+
};
35+
var output = index_1.default(true, input);
36+
input.b.c.d++;
37+
input.b.c.e[2].z.w = null;
38+
input.h = null;
39+
chai_1.assert.deepEqual(original, output);
40+
input = original;
41+
output = index_1.default(true, input, { a: 2 });
42+
chai_1.assert.deepEqual(output.a, 2);
43+
chai_1.assert.deepEqual(input.a, 1);
44+
});
45+
it('invalid input', function () {
46+
chai_1.assert.deepEqual(index_1.default(), {});
47+
chai_1.assert.deepEqual(index_1.default(undefined), {});
48+
chai_1.assert.deepEqual(index_1.default([]), {});
49+
chai_1.assert.deepEqual(index_1.default(true), {});
50+
chai_1.assert.deepEqual(index_1.default(null, true, [0, 1, 2], 3, { a: 1 }, function () { }, undefined, { b: 2 }), { a: 1, b: 2 });
51+
});
52+
it('prototype pollution attack', function () {
53+
chai_1.assert.deepEqual(index_1.default({}, JSON.parse('{"__proto__": {"a": true}}')), {});
54+
});
55+
});
56+
describe('merge.clone', function () {
57+
it('object', function () {
58+
var object1 = { a: 1, b: { c: 2 } };
59+
var object2 = index_1.default.clone(object1);
60+
chai_1.assert.deepEqual(object1, object2);
61+
chai_1.assert.deepEqual(object1 === object2, false);
62+
chai_1.assert.deepEqual(object1.b === object2.b, false);
63+
});
64+
it('array', function () {
65+
var object1 = [{ a: 1, b: { c: 2 } }];
66+
var object2 = index_1.default.clone(object1);
67+
chai_1.assert.deepEqual(object1, object2);
68+
chai_1.assert.deepEqual(object1 === object2, false);
69+
chai_1.assert.deepEqual(object1[0] === object2[0], false);
70+
chai_1.assert.deepEqual(object1[0].b === object2[0].b, false);
71+
});
72+
it('invalid input', function () {
73+
chai_1.assert.deepEqual(index_1.default.clone(null), null);
74+
chai_1.assert.deepEqual(index_1.default.clone(undefined), undefined);
75+
chai_1.assert.deepEqual(index_1.default.clone(1), 1);
76+
chai_1.assert.deepEqual(index_1.default.clone('str'), 'str');
77+
});
78+
});
79+
describe('merge.recursive', function () {
80+
it('basic', function () {
81+
chai_1.assert.deepEqual(index_1.default.recursive({ a: { b: 1 } }, { a: { c: 1 } }), { a: { b: 1, c: 1 } });
82+
chai_1.assert.deepEqual(index_1.default.recursive({ a: { b: 1, c: 1 } }, { a: { b: 2 } }), { a: { b: 2, c: 1 } });
83+
chai_1.assert.deepEqual(index_1.default.recursive({ a: { b: [1, 2, 3], c: 1 } }, { a: { b: ['a'] } }), { a: { b: ['a'], c: 1 } });
84+
chai_1.assert.deepEqual(index_1.default.recursive({ a: { b: { b: 2 }, c: 1 } }, { a: { b: 2 } }), { a: { b: 2, c: 1 } });
85+
});
86+
it('clone', function () {
87+
var test1 = { a: { b: 1 } };
88+
chai_1.assert.deepEqual(index_1.default.recursive(true, test1, { a: { c: 1 } }), { a: { b: 1, c: 1 } });
89+
chai_1.assert.deepEqual({ a: { b: 1 } }, test1);
90+
var test2 = { a: { b: 1, c: 1 } };
91+
chai_1.assert.deepEqual(index_1.default.recursive(true, test2, { a: { b: 2 } }), { a: { b: 2, c: 1 } });
92+
chai_1.assert.deepEqual({ a: { b: 1, c: 1 } }, test2);
93+
var test3 = { a: { b: [1, 2, 3], c: 1 } };
94+
chai_1.assert.deepEqual(index_1.default.recursive(true, test3, { a: { b: ['a'] } }), { a: { b: ['a'], c: 1 } });
95+
chai_1.assert.deepEqual({ a: { b: [1, 2, 3], c: 1 } }, test3);
96+
var test4 = { a: { b: { b: 2 }, c: 1 } };
97+
chai_1.assert.deepEqual(index_1.default.recursive(true, test4, { a: { b: 2 } }), { a: { b: 2, c: 1 } });
98+
chai_1.assert.deepEqual({ a: { b: { b: 2 }, c: 1 } }, test4);
99+
});
100+
it('prototype pollution attack', function () {
101+
chai_1.assert.deepEqual(index_1.default.recursive({}, JSON.parse('{"__proto__": {"a": true}}')), {});
102+
});
103+
});

0 commit comments

Comments
 (0)
Please sign in to comment.