☰

Underdollar jQuery replacement

Replaces jQuery, which causes lots of conflicts, with a framework that is largely cross-compatible

此脚本不应直接安装，它是一个供其他脚本使用的外部库。如果您需要使用该库，请在脚本元属性加入：// @require https://update.cn-greasyfork.org/scripts/37273/246089/Underdollar%20jQuery%20replacement.js 

  1. // ==UserScript==
  2. // @name        Underdollar jQuery replacement
  3. // @namespace   https://greasyfork.org
  4. // @include     https://sellers.shopgoodwill.com/*
  5. // @version     1.1
  6. // @description Replaces jQuery, which causes lots of conflicts, with a framework that is largely cross-compatible
  7. // @grant       none
  8. // ==/UserScript==
  9.  
  10. console.log('ostrich');
  11.  
  12. class underdollar {
  13.     constructor(selector) {
  14. 		this.is_$ = true;
  15. 		var singleNode = (function () {
  16. 			// make an empty node list to inherit from
  17. 			var nodelist = document.createDocumentFragment().childNodes;
  18. 			// return a function to create object formed as desired
  19. 			return function (node) {
  20. 				return Object.create(nodelist, {
  21. 					'0': {value: node, enumerable: true},
  22. 					'length': {value: 1},
  23. 					'item': {
  24. 						"value": function (i) {
  25. 							return this[+i || 0];
  26. 						},
  27. 						enumerable: true
  28. 					}
  29. 				}); // return an object pretending to be a NodeList
  30. 			};
  31. 		}());
  32.  
  33. 		if (arguments.length < 1 || typeof selector == 'undefined') {
  34. 			this.nodeList = 'empty';
  35. 		} else {
  36. 			if (selector instanceof Element) {
  37. 				this.nodeList = singleNode(selector);
  38. 			} else if (selector instanceof NodeList || selector instanceof HTMLCollection) {
  39. 				this.nodeList = selector;
  40. 			} else if (selector instanceof Array) {
  41. 				selector.forEach(function(el) {
  42. 					if (el instanceof Element) {
  43. 						el.classList.add('udTempClassSelector');
  44. 					}
  45. 				});
  46. 				this.nodeList = _$('.udTempClassSelector').nodeList;
  47. 				Array.prototype.forEach.call(_$('.udTempClassSelector').nodeList, function(el) {
  48. 					el.classList.remove('udTempClassSelector');
  49. 				});
  50. 			} else {
  51. 				this.nodeList = document.querySelectorAll(selector);
  52. 			}
  53. 			this.selector = selector;
  54. 		}
  55. 		Array.prototype.forEach.call(document.querySelectorAll('.udTempClassSelector'), function(el) {
  56. 			el.classList.remove('.udTempClassSelector');
  57. 		});
  58.  
  59. 		this.length = this.nodeList.length;
  60. 		
  61. 		var nodeArray = [];
  62. 		for (var i=0; i<this.length; i++) {
  63. 			this[i] = this.nodeList[i];
  64. 		}
  65. 	}
  66.  
  67. // selection functions
  68.  
  69. 	parent() {
  70. 		if (this.nodeList instanceof NodeList) {
  71. 			var myParent = this.nodeList[0].parentNode;
  72. 			return _$(myParent);
  73. 		}
  74. 	}
  75.  
  76. 	children() {
  77. 		return _$(this.nodeList[0].children);
  78. 	}
  79.  
  80. 	first() {
  81. 		if (this.nodeList instanceof NodeList) {
  82. 			return _$(this.nodeList[0]);
  83. 		} else {
  84. 			return _$(this.selector);
  85. 		}
  86. 	}
  87.  
  88. 	last() {
  89. 		if (this.nodeList instanceof NodeList) {
  90. 			var length = this.nodeList.length;
  91. 			this.nodeList[length-1].classList.add('udLastTempClass');
  92. 			var returnThis = _$('.udLastTempClass');
  93. 			_$('.udLastTempClass').removeClass('.udLastTempClass');
  94. 			return returnThis;
  95. 		} else {
  96. 			return _$(this.selector);
  97. 		}
  98. 	}
  99.  
  100. 	nth(pos) { // Takes 1-indexed values
  101. 		pos -= 1;
  102. 		return _$(this[pos]);
  103. 	}
  104. 	
  105. 	index(pos) { // Takes 0-indexed values
  106. 		return _$(this[pos]);
  107. 	}
  108. 	
  109. 	next() {
  110. 		return _$(this[this.length-1].nextElementSibling);
  111. 	}
  112. 	
  113. 	contents() {
  114. //		var frame = document.getElementById('myframe');
  115. //		var c = frame.contentDocument || frame.contentWindow.document;
  116. 		return this.nodeList[0].contentDocument || this.nodeList[0].contentWindow.document;
  117. 	}
  118.  
  119.  
  120.  
  121. // display functions
  122.  
  123. 	css(arg1, arg2){
  124. 		var me = this;
  125. 		if (typeof arg1 == 'string' && typeof arg2 == 'string') {
  126. 			Array.prototype.forEach.call(this.nodeList, function(el){
  127. 				el.style[arg1] = arg2;
  128. 			});
  129. 		} else if (arg1 instanceof Object) {
  130. 			Array.prototype.forEach.call(this.nodeList, function(el) {
  131. 				_$().each(arg1, function(styleName, styleValue) {
  132. 					el.style[styleName] = styleValue;
  133. 				});
  134. 			});
  135. 		}
  136.  
  137. 		return _$(this.selector);
  138. 	}
  139.  
  140. 	hide() {
  141. 		this.css('display', 'none');
  142. 		return _$(this.selector);
  143. 	}
  144.  
  145. 	show() {
  146. 		this.css('display', '');
  147. 		return _$(this.selector);
  148. 	}
  149.  
  150. 	toggle() {
  151. 		if (this.nodeList instanceof NodeList) {
  152. 			this.each(function(el){
  153. 				if (el.style.display == 'none') {
  154. 					el.style.display = '';
  155. 				} else {
  156. 					el.style.display = 'none';
  157. 				}
  158. 			});
  159. 		}
  160. 		return _$(this.selector);
  161. 	}
  162.  
  163. // DOM functions
  164.  
  165. 	before(htmlString) {
  166. 		this.each(function(el){
  167. 			el.insertAdjacentHTML('beforebegin', htmlString);
  168. 		});
  169. 		return _$(this.selector);
  170. 	}
  171.  
  172. 	after(htmlString) {
  173. 		this.each(function(el){
  174. 			el.insertAdjacentHTML('afterend', htmlString);
  175. 		});
  176. 		return _$(this.selector);
  177. 	}
  178.  
  179. 	append(something) {
  180. 		if (something instanceof Element) {
  181. 			this.each(function(el) {
  182. 				// how to function with appending one existing thing when there are multiple things to append to??
  183. 				el.appendChild(something);
  184.  
  185. 			});
  186. 		} else if (something instanceof NodeList) {
  187. 			Array.prototype.forEach.call(something, function(el) {
  188. 				this.append(something);
  189. 			});
  190. 		} else if (typeof something == 'string') {
  191. 			this.each(function(el) {
  192. 				var newEl = document.createElement('text');
  193. 				newEl.innerHTML = something;
  194. 				el.appendChild(newEl)
  195. 			});
  196. 		} else if (something.hasOwnProperty('is_$')) {
  197. 			if (something.nodeList.length == 1) {
  198. 				this.each(function(el) {
  199. 					// how to function with appending one existing thing when there are multiple things to append to??
  200. 					el.appendChild(something.nodeList[0]);
  201. 				});
  202. 			} else if (something.nodeList.length > 1) {
  203. 				this.each(function(el) {
  204. 					// how to function with appending one existing thing when there are multiple things to append to??
  205. 					//el.appendChild(something.nodeList[0]);
  206. 					Array.prototype.forEach.call(something.nodeList, function(myNode, nodeIndex) {
  207. 						el.appendChild(myNode);
  208. 					});
  209. 				});
  210. 			}
  211. 		}
  212. 		return _$(this.selector);
  213. 	}
  214.  
  215. 	prepend(something) {
  216. 		if (something instanceof Element) {
  217. 			this.each(function(el) {
  218. 				// how to function with appending one existing thing when there are multiple things to append to??
  219. 				el.insertBefore(something, el.firstChild);
  220.  
  221. 			});
  222. 		} else if (something instanceof NodeList) {
  223. 			Array.prototype.forEach.call(something, function(el) {
  224. 				this.append(something, el.firstChild);
  225. 			});
  226. 		} else if (typeof something == 'string') {
  227. 			this.each(function(el) {
  228. 				var newEl = document.createElement('text');
  229. 				newEl.innerHTML = something;
  230. 				el.insertBefore(newEl, el.firstChild)
  231. 			});
  232. 		} else if (something.hasOwnProperty('is_$')) {
  233. 			if (something.nodeList.length == 1) {
  234. 				this.each(function(el) {
  235. 					// how to function with appending one existing thing when there are multiple things to append to??
  236. 					el.insertBefore(something.nodeList[0], el.firstChild);
  237. 				});
  238. 			} else if (something.nodeList.length > 1) {
  239. 				this.each(function(el) {
  240. 					// how to function with appending one existing thing when there are multiple things to append to??
  241. 					Array.prototype.forEach.call(something.nodeList, function(myNode, nodeIndex) {
  242. 						el.insertBefore(myNode, el.firstChild);
  243. 					});
  244. 				});
  245. 			}
  246. 		}
  247. 		return _$(this.selector);
  248. 	}
  249.  
  250. 	remove() {
  251. 		this.each(function(el) {
  252. 			el.parentNode.removeChild(el);
  253. 		});
  254. 	}
  255.  
  256. 	wrap(htmlString) {
  257. 		this.after(htmlString);
  258. 		var newEl = this.next();
  259. 		newEl.prepend(this);
  260. 	}
  261. 	
  262. 	wrapInner(htmlString) {
  263. 		this.after(htmlString);
  264. 		var newEl = this.next();
  265. 		console.dir(this.children());
  266. 		Array.prototype.forEach.call(this.children(), function(el) {
  267. 			newEl.prepend(el);
  268. 		});
  269. 		this.prepend(newEl);
  270. 		//this.children().wrap(htmlString);
  271. 	}
  272. 	
  273. // other element property/content functions
  274.  
  275. 	attr(arg1, arg2) {
  276. 		if (arguments.length < 2) {
  277. 			return this.nodeList[0].getAttribute(arg1);
  278. 		} else {
  279. 			this.each(function(el) {
  280. 				el.setAttribute(arg1, arg2);
  281. 			});
  282. 			return _$(this.selector);
  283. 		}
  284. 	}
  285.  
  286. 	text(textString) {
  287. 		if (arguments.length < 1) {
  288. 			var myVal = '';
  289. 			this.each(function(el){
  290. 				myVal += el.textContent;
  291. 			});
  292. 			return myVal;
  293. 		} else {
  294. 			this.each(function(el){
  295. 				el.textContent = textString;
  296. 			});
  297. 			return _$(this.selector);
  298. 		}
  299. 	}
  300.  
  301. 	html(arg1) {
  302. 		if (arguments.length < 1) {
  303. 			var myVal = '';
  304. 			this.each(function(el){
  305. 				myVal += el.innerHTML;
  306. 			});
  307. 			return myVal;
  308. 		} else {
  309. 			this.each(function(el){
  310. 				el.innerHTML = arg1;
  311. 			});
  312. 			return _$(this.selector);
  313. 		}
  314. 	}
  315.  
  316. 	val(arg1) {
  317. 		if (arguments.length < 1) {
  318. 			if (this.length > 1) {
  319. 				var myVals = [];
  320. 				this.each(function(el){
  321. 					myVals.push(el.value)
  322. 				});
  323. 				return myVals;
  324. 			} else if (this.length == 1) {
  325. 				return this.nodeList[0].value;
  326. 			}
  327. 		} else {
  328. 			this.each(function(el){
  329. 				el.value = arg1;
  330. 			});
  331. 			return _$(this.selector);
  332. 		}
  333. 	}
  334.  
  335. 	isVisible() {
  336. 		if (this.length == 1) {
  337. 			return this.nodeList[0].offsetWidth !== 0 && this.nodeList[0].offsetHeight !== 0;
  338. 		} else if (this.length == 1) {
  339. 			var numVisible = 0;
  340. 			this.each(function(el){
  341. 				if (!(el.offsetWidth !== 0) || !(el.offsetHeight !== 0)) {
  342. 					numVisible++;
  343. 				}
  344. 			});
  345. 			return numVisible;
  346. 		}
  347. 	}
  348.  
  349. // class functions
  350.  
  351. 	addClass(classNames) {
  352. 		var classNameList = classNames.split(/[ ,]/gim);
  353. 		this.each(function(el) {
  354. 			_$().each(classNameList, function(index, val) {
  355. 				if (val.length > 0) {
  356. 					el.classList.add(val);
  357. 				}
  358. 			});
  359. 		});
  360. 	}
  361. 	
  362. 	removeClass(classNames) {
  363. 		var classNameList = classNames.split(/[ ,]/gim);
  364. 		this.each(function(el) {
  365. 			_$().each(classNameList, function(index, val) {
  366. 				if (val.length > 0) {
  367. 					el.classList.remove(val);
  368. 				}
  369. 			});
  370. 		});
  371. 	}
  372. 	
  373. 	toggleClass(classNames) {
  374. 		var classNameList = classNames.split(/[ ,]/gim);
  375. 		this.each(function(el) {
  376. 			_$().each(classNameList, function(index, val) {
  377. 				if (val.length > 0) {
  378. 					el.classList.toggle(val);
  379. 				}
  380. 			});
  381. 		});
  382. 	}
  383. 	
  384. 	replaceClass(oldClass, newClass) {
  385. 		this.each(function(el) {
  386. 			el.classList.replace(oldClass, newClass);
  387. 		});
  388. 	}
  389.  
  390. // event functions
  391.  
  392. 	bind(eventName, fn) {
  393. 		Array.prototype.forEach.call(this.nodeList, function(el) {
  394. 			el.addEventListener(eventName, fn);
  395. 		});
  396.  
  397. 	}
  398. 	
  399. 	trigger(eventName) {
  400. 		var event = document.createEvent('HTMLEvents');
  401. 		event.initEvent(eventName, true, false);
  402. 		this.each(function(el){
  403. 			el.dispatchEvent(event);
  404. 		});
  405. 	}
  406.  
  407. // json functions
  408.  
  409. 	getJSON(url, placeholder, fn) {
  410. 		var Httpreq = new XMLHttpRequest(); // a new request
  411. 		Httpreq.open("GET",url,false);
  412. 		Httpreq.send(null);
  413. 		var data = JSON.parse(Httpreq.responseText);
  414. 		if (arguments.length > 2) {
  415. 			fn(data);
  416. 		}
  417. 		return data;
  418. 	}
  419. 	
  420. // utility functions
  421.  
  422. 	filter(fn) {
  423. 		this.each(function(el){
  424. 			if (fn(el)) {
  425. 				el.classList.add('udFilterTempClass');
  426. 			}
  427. 		});
  428. 		var returnThis = _$('.udFilterTempClass');
  429. 		_$('.udFilterTempClass').each(function(el) {
  430. 			el.classList.remove('udFilterTempClass');
  431. 		});
  432. 		
  433. 		
  434. //		var returnThis = Array.prototype.filter.call(this.nodeList, fn);
  435. //		console.dir(returnThis);
  436. 		return returnThis;
  437. 	}
  438.  
  439. 	each(arg1, arg2){
  440. 		if (arg1 instanceof Object && arg2 instanceof Function) {
  441. 				for (var p in arg1) {
  442. 					if (arg1.hasOwnProperty(p)) {
  443. 						arg2(p, arg1[p]);
  444. 					}
  445. 			}
  446. 		} else if (arg1 instanceof Array && arg2 instanceof Function) {
  447. 			Array.prototype.forEach.call(arg1, arg2);
  448. 		} else if (this.nodeList instanceof Array || this.nodeList instanceof NodeList) {
  449. 			Array.prototype.forEach.call(this.nodeList, arg1);
  450. 		}
  451.  
  452. 		return _$(this.selector);
  453. 	}
  454.  
  455. 	iterateOverObject(obj, fn) {
  456. 		if (obj instanceof Object) {
  457. 			for (var p in obj) {
  458. 				if (obj.hasOwnProperty(p)) {
  459. 					fn(p, obj[p]);
  460. 				}
  461. 			}
  462. 		}
  463.  
  464. 		return _$(this.selector);
  465. 	}
  466.  
  467. }
  468.  
  469. function _$(selector) {
  470. 	return new underdollar(selector);
  471. }