@shgysk8zer0/polyfills 0.0.2

package/iterator.js

@@ -0,0 +1,197 @@
+(function() {
+	'use strict';
+
+	/**
+	 * @see https://github.com/tc39/proposal-iterator-helpers
+	 * @TODO implement `flat()`
+	 * @TODO implement `flatMap()`
+	 * @TODO implement `from()`
+	 */
+	if (! ('Iterator' in globalThis)) {
+		globalThis.Iterator = {
+			'prototype': Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]())),
+		};
+	}
+
+	const Iterator = globalThis.Iterator;
+
+	if (! (Iterator.range instanceof Function)) {
+		Iterator.range = function* range(start, end, option) {
+			if (typeof option === 'number' || typeof option === 'bigint') {
+				for (const n of Iterator.range(start, end, { step: option })) {
+					yield n;
+				}
+			} else if (typeof option !== 'object' || Object.is(option, null)) {
+				for (const n of Iterator.range(start, end, {})) {
+					yield n;
+				}
+			} else {
+				const {
+					// Default to +/-, Number/BigInt based on start & end
+					step = typeof start === 'number'
+						? start < end ? 1 : -1
+						: start < end ? 1n : -1n,
+					inclusive = false,
+				} = option;
+
+				if (typeof start !== 'number' && typeof start !== 'bigint') {
+					throw new TypeError('Start must be a number');
+				} else if (Number.isNaN(start)) {
+					throw new RangeError('Invalid start');
+				} else if (typeof end !== 'number' && typeof end !== 'bigint') {
+					throw new TypeError('End must be a number');
+				} else if (Number.isNaN(end)) {
+					throw new RangeError('Invalid end');
+				} else if (typeof step !== 'number' && typeof step !== 'bigint') {
+					throw new TypeError('Step must be a number');
+				} else if (Number.isNaN(step)) {
+					throw new RangeError('Invalid step');
+				} else if (step === 0) {
+					throw new RangeError('Step must not be 0');
+				} else if ((step < 0 && start < end) || (step > 0 && start > end)) {
+					return;
+				} else if (inclusive) {
+					if (step > 0) {
+						for (let n = start; n <= end; n+= step) {
+							yield n;
+						}
+					} else {
+						for (let n = start; n >= end; n+= step) {
+							yield n;
+						}
+					}
+				} else {
+					if (step > 0) {
+						for (let n = start; n < end; n+= step) {
+							yield n;
+						}
+					} else {
+						for (let n = start; n > end; n+= step) {
+							yield n;
+						}
+					}
+				}
+			}
+		};
+	}
+
+	if (! (Iterator.prototype[Symbol.toStringTag])) {
+		Iterator.prototype[Symbol.toStringTag] = 'Iterator';
+	}
+
+	if (! (Iterator.prototype.take instanceof Function)) {
+		Iterator.prototype.take = function* take(limit) {
+			let n = 0;
+
+			for (const item of this) {
+				if (++n > limit) {
+					break;
+				} else {
+					yield item;
+				}
+			}
+		};
+	}
+
+	if (! (Iterator.prototype.drop instanceof Function)) {
+		Iterator.prototype.drop = function* drop(limit) {
+			let n = 0;
+			for (const item of this) {
+				if (n++ >= limit) {
+					yield item;
+				}
+			}
+		};
+	}
+
+	if (! (Iterator.prototype.toArray instanceof Function)) {
+		Iterator.prototype.toArray = function toArray() {
+			return Array.from(this);
+		};
+	}
+
+	if (! (Iterator.prototype.forEach instanceof Function)) {
+		Iterator.prototype.forEach = function forEach(callback) {
+			for (const item of this) {
+				callback(item);
+			}
+		};
+	}
+
+	if (! (Iterator.prototype.map instanceof Function)) {
+		Iterator.prototype.map = function* map(callback) {
+			for (const item of this) {
+				yield callback(item);
+			}
+		};
+	}
+
+	if (! (Iterator.prototype.reduce instanceof Function)) {
+		Iterator.prototype.reduce = function reduce(callback, initialValue) {
+			let current = typeof initialValue === 'undefined' ? this.next().value : initialValue;
+
+			for (const item of this) {
+				current = callback(current, item);
+			}
+
+			return current;
+		};
+	}
+
+	if (! (Iterator.prototype.filter instanceof Function)) {
+		Iterator.prototype.filter = function* filter(callback) {
+			for (const item of this) {
+				if (callback(item)) {
+					yield item;
+				}
+			}
+		};
+	}
+
+	if (! (Iterator.prototype.some instanceof Function)) {
+		Iterator.prototype.some = function some(callback) {
+			let retVal = false;
+			for (const item of this) {
+				if (callback(item)) {
+					retVal = true;
+					break;
+				}
+			}
+
+			return retVal;
+		};
+	}
+
+	if (! (Iterator.prototype.every instanceof Function)) {
+		Iterator.prototype.every = function every(callback) {
+			let retVal = true;
+			for (const item of this) {
+				if (! callback(item)) {
+					retVal = false;
+					break;
+				}
+			}
+
+			return retVal;
+		};
+	}
+
+	if (! (Iterator.prototype.find instanceof Function)) {
+		Iterator.prototype.find = function find(callback) {
+			for (const item of this) {
+				if (callback(item)) {
+					return item;
+				}
+			}
+		};
+	}
+
+	if (! (Iterator.prototype.indexed instanceof Function)) {
+		Iterator.prototype.indexed = function* indexed() {
+			let n = 0;
+			for (const item of this) {
+				yield [n++, item];
+			}
+		};
+	}
+})();

package/legacy/array.js

@@ -0,0 +1,15 @@
+(function() {
+	'use strict';
+
+	if (! (Array.from instanceof Function)) {
+		Array.from = function from(iter) {
+			return Array.of(...iter);
+		};
+	}
+
+	if (! (Array.of instanceof Function)) {
+		Array.of = function of(...items) {
+			return items;
+		};
+	}
+})();

package/legacy/element.js

@@ -0,0 +1,140 @@
+(function() {
+	'use strict';
+
+	if (! (Element.prototype.closest instanceof Function)) {
+		Element.prototype.closest = function closest(selector) {
+			if (this.matches(selector)) {
+				return this;
+			} else {
+				let found = null;
+				let target = this.parentElement;
+
+				while(target instanceof Element) {
+					if (target.matches(selector)) {
+						found = target;
+						break;
+					} else {
+						target = target.parentElement;
+					}
+				}
+
+				return found;
+			}
+		};
+	}
+
+	if (! (Element.prototype.toggleAttribute instanceof Function)) {
+		Element.prototype.toggleAttribute = function(name, force) {
+			if (typeof force === 'undefined') {
+				return this.toggleAttribute(name, ! this.hasAttribute(name));
+			} else if (force) {
+				this.setAttribute(name, '');
+				return true;
+			} else {
+				this.removeAttribute(name);
+				return false;
+			}
+		};
+	}
+
+	if (! (Element.prototype.remove instanceof Function)) {
+		Element.prototype.remove = function remove() {
+			if (this.parentNode instanceof Node) {
+				this.parentNode.removeChild(this);
+			}
+		};
+	}
+
+	if (! (Element.prototype.after instanceof Function)) {
+		Element.prototype.after = function after(...items) {
+			items.forEach(item => {
+				if (item instanceof Node) {
+					this.insertAdjacentElement('afterend', item);
+				} else {
+					this.insertAdjacentText('afterend', item);
+				}
+			});
+		};
+	}
+
+	if (! (Element.prototype.before instanceof Function)) {
+		Element.prototype.before = function before(...items) {
+			items.forEach(item => {
+				if (item instanceof Node) {
+					this.insertAdjacentElement('beforebegin', item);
+				} else {
+					this.insertAdjacentText('beforebegin', item);
+				}
+			});
+		};
+	}
+
+	if (! (Element.prototype.append instanceof Function)) {
+		Element.prototype.append = function append(...items) {
+			items.forEach(item => {
+				if (item instanceof Node) {
+					this.appendChild(item);
+				} else {
+					this.appendChild(document.createTextNode(item));
+				}
+			});
+		};
+	}
+
+	if (! (Element.prototype.prepend instanceof Function)) {
+		Element.prototype.prepend = function prepend(...items) {
+			items.forEach(item => {
+				if (item instanceof Node) {
+					this.insertAdjacentElement('afterbegin', item);
+				} else {
+					this.insertAdjacentText('afterbegin', item);
+				}
+			});
+		};
+	}
+
+	if (! (Element.prototype.replaceWith instanceof Function)) {
+		Element.prototype.replaceWith = function replaceWith(...items) {
+			this.before(...items);
+			this.remove();
+		};
+	}
+
+	if (! (Element.prototype.replaceChildren instanceof Function)) {
+		Element.prototype.replaceChildren = function(...items) {
+			[...this.children].forEach(el => el.remove());
+			this.append(...items);
+		};
+
+		Document.prototype.replaceChildren = function(...items) {
+			Element.prototype.replaceChildren.apply(this, items);
+		};
+
+		DocumentFragment.prototype.replaceChildren = function(...items) {
+			Element.prototype.replaceChildren.apply(this, items);
+		};
+
+		if ('ShadowRoot' in globalThis) {
+			ShadowRoot.prototype.replaceChildren = function(...items) {
+				Element.prototype.replaceChildren.apply(this, items);
+			};
+		}
+	}
+
+	if (! (Element.prototype.getAttributeNames instanceof Function)) {
+		Element.prototype.getAttributeNames = function() {
+			return Array.from(this.attributes).map(({ name }) => name);
+		};
+	}
+
+	if (! ('hidden' in Element.prototype)) {
+		Object.defineProperty(Element.prototype, 'hidden', {
+			get: function() {
+				return this.hasAttribute('hidden');
+			},
+			set: function(value) {
+				this.toggleAttribute('hidden', value);
+			}
+		});
+	}
+})();

package/legacy/map.js

@@ -0,0 +1,168 @@
+(function() {
+	'use strict';
+
+	if (! ('WeakMap' in globalThis)) {
+		const symbols = {
+			keys: Symbol('keys'),
+			values: Symbol('values'),
+		};
+
+		globalThis.WeakMap = class WeakMap {
+			constructor(init) {
+				Object.defineProperties(this, {
+					[symbols.keys]: {
+						enumerable: false,
+						configurable: false,
+						writable: false,
+						value: [],
+					},
+					[symbols.values]: {
+						enumerable: false,
+						configurable: false,
+						writable: false,
+						value: [],
+					},
+				});
+
+				if (typeof init !== 'undefined' && Symbol.iterator in init) {
+					for (const [key, value] of init) {
+						this.set(key, value);
+					}
+				}
+			}
+
+			has(key) {
+				return this[symbols.keys].includes(key);
+			}
+
+			set(key, value) {
+				const existing = this[symbols.keys].indexOf(key);
+
+				if (existing !== -1) {
+					this[symbols.values][existing] = value;
+				} else {
+					this[symbols.keys].push(key);
+					this[symbols.values].push(value);
+				}
+
+				return this;
+			}
+
+			get(key) {
+				const index = this[symbols.keys].indexOf(key);
+				return index === -1 ? undefined : this[symbols.values][index];
+			}
+
+			delete(key) {
+				const index = this[symbols.keys].indexOf(key);
+				if (index === -1) {
+					return false;
+				} else {
+					this[symbols.keys].splice(index, 1);
+					this[symbols.values].splice(index, 1);
+					return true;
+				}
+			}
+		};
+	}
+
+	if (! ('Map' in globalThis)) {
+		const symbols = {
+			keys: Symbol('keys'),
+			values: Symbol('values'),
+		};
+
+		globalThis.Map = class Map {
+			constructor(init) {
+				Object.defineProperties(this, {
+					[symbols.keys]: {
+						enumerable: false,
+						configurable: false,
+						writable: true,
+						value: [],
+					},
+					[symbols.values]: {
+						enumerable: false,
+						configurable: false,
+						writable: true,
+						value: [],
+					},
+				});
+
+				if (typeof init !== 'undefined' && Symbol.iterator in init) {
+					for (const [key, value] of init) {
+						this.set(key, value);
+					}
+				}
+			}
+
+			get size() {
+				return this[symbols.keys].length;
+			}
+
+			clear() {
+				this[symbols.keys] = [];
+				this[symbols.values] = [];
+			}
+
+			has(key) {
+				return this[symbols.keys].includes(key);
+			}
+
+			set(key, value) {
+				const existing = this[symbols.keys].indexOf(key);
+
+				if (existing !== -1) {
+					this[symbols.values][existing] = value;
+				} else {
+					this[symbols.keys].push(key);
+					this[symbols.values].push(value);
+				}
+
+				return this;
+			}
+
+			get(key) {
+				const index = this[symbols.keys].indexOf(key);
+				return index === -1 ? undefined : this[symbols.values][index];
+			}
+
+			delete(key) {
+				const index = this[symbols.keys].indexOf(key);
+				if (index === -1) {
+					return false;
+				} else {
+					this[symbols.keys].splice(index, 1);
+					this[symbols.values].splice(index, 1);
+					return true;
+				}
+			}
+
+			*keys() {
+				for (const key of this[symbols.keys]) {
+					yield key;
+				}
+			}
+
+			*values() {
+				for (const value of this[symbols.values]) {
+					yield value;
+				}
+			}
+
+			*entries() {
+				for (let n = 0; n < this.size; n++) {
+					yield [this[symbols.keys][n], this[symbols.values][n]];
+				}
+			}
+
+			[Symbol.iterator]() {
+				return this.entries();
+			}
+
+			forEach(callback, thisArg = globalThis) {
+				[...this.entries()].forEach(([key, value]) => callback.call(thisArg, value, key, this));
+			}
+		};
+	}
+})();

package/legacy/object.js

@@ -0,0 +1,42 @@
+(function() {
+	'use strict';
+
+	if (! (Object.hasOwn instanceof Function)) {
+		Object.hasOwn = function hasOwn(obj, prop) {
+			return Object.prototype.hasOwnProperty.call(obj, prop);
+		};
+	}
+
+	if (! (Object.keys instanceof Function)) {
+		Object.keys = function keys(obj) {
+			const arr = [];
+
+			for (const k in obj) {
+				arr.push(k);
+			}
+
+			return arr;
+		};
+	}
+
+	if (! (Object.values instanceof Function)) {
+		Object.values = obj => Object.keys(obj).map(k => obj[k]);
+	}
+
+	if (! (Object.entries instanceof Function)) {
+		Object.entries = obj => Object.keys(obj).map(k => [k, obj[k]]);
+	}
+
+	if (! (Object.fromEntries instanceof Function)) {
+		Object.fromEntries = function(arr) {
+			if (Array.isArray(arr)) {
+				return arr.reduce((obj, [key, val]) => {
+					obj[key] = val;
+					return obj;
+				}, {});
+			} else {
+				return Object.fromEntries(Array.from(arr));
+			}
+		};
+	}
+})();

package/legacy.js

@@ -0,0 +1,9 @@
+/**
+ * Import modules to improve support in legacy browsers.
+ * Note: load order may be crucial, as some polyfills may rely on
+ * e.g. `Object.fromEntries()`
+ */
+import './legacy/object.js';
+import './legacy/array.js';
+import './legacy/map.js';
+import './legacy/element.js';

package/locks.js

@@ -0,0 +1,33 @@
+import { LockManager, actuallySupported, nativeSupport } from './assets/LockManager.js';
+import { errorToEvent } from './assets/error.js';
+let polyfilled = false;
+
+const polyfilledPromise = new Promise(async resolve => {
+	if (nativeSupport) {
+		if (await actuallySupported) {
+			resolve(false);
+		} else {
+			try {
+				navigator.locks.request = LockManager.request;
+				navigator.locks.query = LockManager.query;
+				polyfilled = true;
+				resolve(true);
+			} catch(err) {
+				globalThis.dispatchEvent(errorToEvent(err));
+				resolve(false);
+			}
+		}
+	} else {
+		try {
+			navigator.locks = LockManager;
+			polyfilled = true;
+			resolve(true);
+		} catch(err) {
+			globalThis.dispatchEvent(errorToEvent(err));
+			resolve(false);
+		}
+	}
+});
+
+
+export { polyfilled, polyfilledPromise };

package/map.js

@@ -0,0 +1,32 @@
+(function() {
+	'use strict';
+
+	/**
+	 * @see https://github.com/tc39/proposal-upsert
+	 */
+
+	if (! (Map.prototype.emplace instanceof Function)) {
+		Map.prototype.emplace = function emplace(key, { insert, update } = {}) {
+			const has = this.has(key);
+
+			if (has && update instanceof Function) {
+				const existing = this.get(key);
+				const value = update.call(this, existing, key, this);
+
+				if (value !== existing) {
+					this.set(key, value);
+				}
+
+				return value;
+			} else if (has) {
+				return this.get(key);
+			} else if (insert instanceof Function) {
+				const value = insert.call(this, key, this);
+				this.set(key, value);
+				return value;
+			} else {
+				throw new Error('Key is not found and no `insert()` given');
+			}
+		};
+	}
+})();

package/match-media.js

@@ -0,0 +1,58 @@
+(function() {
+	'use strict';
+
+	if (! ('MediaQueryListEvent' in globalThis)) {
+		/**
+		 * @see https://developer.mozilla.org/en-US/docs/Web/API/MediaQueryListEvent
+		 */
+		globalThis.MediaQueryListEvent = class MediaQueryListEvent extends Event {
+			constructor(type, { media, matches } = {}) {
+				super(type);
+				Object.defineProperties(this, {
+					'media': {
+						enumerable: true,
+						configurable: false,
+						writable: false,
+						value: media,
+					},
+					'matches': {
+						enumerable: true,
+						configurable: false,
+						writable: false,
+						value: matches,
+					},
+				});
+			}
+		};
+	}
+
+	if ('MediaQueryList' in globalThis && ! (globalThis.MediaQueryList.prototype.addEventListener instanceof Function)) {
+		const targets = new WeakMap();
+
+		const listener = function listener() {
+			const { media, matches } = this;
+			this.dispatchEvent(new MediaQueryListEvent('change', { media, matches }));
+		};
+
+		const init = function init(mql) {
+			if (! targets.has(mql)) {
+				targets.set(mql, new EventTarget());
+				mql.addListener(listener.bind(mql));
+			}
+
+			return targets.get(mql);
+		};
+
+		globalThis.MediaQueryList.prototype.addEventListener = function addEventListener(type, callback, opts) {
+			init(this).addEventListener(type, callback, opts);
+		};
+
+		globalThis.MediaQueryList.prototype.removeEventListener = function removeEventListner(type, callback, opts) {
+			init(this).removeEventListener(type, callback, opts);
+		};
+
+		globalThis.MediaQueryList.prototype.dispatchEvent = function dispatchEvent(event) {
+			init(this).dispatchEvent(event);
+		};
+	}
+})();