@shgysk8zer0/polyfills 0.0.2

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Chris Zuber
+
+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/README.md

@@ -0,0 +1,2 @@
+# polyfills
+A set of JavaScript polyfills

package/abort.js

@@ -0,0 +1,194 @@
+(function() {
+	'use strict';
+
+	if (! ('AbortSignal' in globalThis)) {
+		const symbols = {
+			signal: Symbol('signal'),
+			aborted: Symbol('aborted'),
+			reason: Symbol('reason'),
+			onabort: Symbol('onabort'),
+		};
+
+		globalThis.AbortError = class AbortError extends Error {};
+
+		globalThis.AbortSignal = class AbortSignal extends EventTarget {
+			constructor() {
+				super();
+
+				Object.defineProperties(this,{
+					[symbols.aborted]: {
+						enumerable: false,
+						writable: true,
+						configurable: false,
+						value: false,
+					},
+					[symbols.reason]: {
+						enumerable: false,
+						writable: true,
+						configurable: false,
+						value: undefined,
+					},
+					[symbols.onabort]: {
+						enumerable: false,
+						writable: true,
+						configurable: false,
+						value: null,
+					},
+				});
+
+				this.addEventListener('abort', event => {
+					if (this.onabort instanceof Function) {
+						this.onabort.call(this, event);
+					}
+				});
+			}
+
+			get aborted() {
+				return this[symbols.aborted];
+			}
+
+			get onabort() {
+				return this[symbols.onabort];
+			}
+
+			set onabort(value) {
+				if (value instanceof Function) {
+					this[symbols.onabort] = value;
+				} else {
+					this[symbols.onabort] = null;
+				}
+			}
+
+			get reason() {
+				return this[symbols.reason];
+			}
+
+			throwIfAborted() {
+				if (this.aborted) {
+					throw this.reason;
+				}
+			}
+
+			static abort(reason = new DOMException('Operation aborted')) {
+				const signal = new AbortSignal();
+				signal[symbols.aborted] = true;
+				signal[symbols.reason] = reason;
+				return signal;
+			}
+		};
+
+		globalThis.AbortController = class AbortController {
+			constructor() {
+				this[symbols.signal] = new AbortSignal();
+			}
+
+			get signal() {
+				return this[symbols.signal];
+			}
+
+			abort(reason = new DOMException('Operation aborted')) {
+				const signal = this.signal;
+
+				if (! signal.aborted) {
+					signal[symbols.aborted] = true;
+					signal[symbols.reason] = reason;
+					signal.dispatchEvent(new Event('abort'));
+				}
+			}
+		};
+	}
+
+	if (! ('reason' in AbortSignal.prototype)) {
+		const reasons = new WeakMap();
+		const abort = AbortController.prototype.abort;
+
+		if (AbortSignal.abort instanceof Function) {
+			const staticAbort = AbortSignal.abort;
+
+			AbortSignal.abort = function(reason = new DOMException('Operation aborted')) {
+				const signal = staticAbort();
+				reasons.set(signal, reason);
+				return signal;
+			};
+		} else {
+			AbortSignal.abort = function abort(reason = new DOMException('Operation aborted')) {
+				const controller = new AbortController();
+				controller.abort(reason);
+				return controller.reason;
+			};
+		}
+
+		Object.defineProperty(AbortSignal.prototype, 'reason', {
+			enumerable: true,
+			configurable: true,
+			get: function() {
+				if (reasons.has(this)) {
+					return reasons.get(this);
+				} else {
+					return undefined;
+				}
+			}
+		});
+
+		AbortController.prototype.abort = function(reason = new DOMException('Operation aborted')) {
+			reasons.set(this.signal, reason);
+			abort.call(this);
+		};
+	}
+
+	if (! (AbortSignal.prototype.throwIfAborted instanceof Function)) {
+		AbortSignal.prototype.throwIfAborted = function() {
+			if (this.aborted) {
+				throw this.reason;
+			}
+		};
+	}
+
+	if (! (AbortSignal.timeout instanceof Function)) {
+		AbortSignal.timeout = function(ms) {
+			if (typeof ms === 'undefined') {
+				throw new TypeError('At least one 1 argument required but only 0 passed');
+			} else if (! Number.isFinite(ms)) {
+				throw new TypeError('Argument 1 is not a finite value, so it is out of range for unsigned long long.');
+			} else if (ms < 0) {
+				throw new TypeError('Argument 1 is out of range for unsigned long long.');
+			} else {
+				const controller = new AbortController();
+				setTimeout(() => controller.abort(new DOMException('The operation timed out.')), ms);
+				return controller.signal;
+			}
+		};
+	}
+
+	/**
+	 * @see https://chromestatus.com/feature/5202879349522432
+	 * @TODO How do I handle if a signal is already aborted
+	 * @TODO Should controller abort on a TypeError
+	 */
+	if (! (AbortSignal.any instanceof Function)) {
+		AbortSignal.any = function(signals) {
+			if (! Array.isArray(signals)) {
+				throw new TypeError('Expected an array of signals');
+			}
+
+			const controller = new AbortController();
+
+			for (const signal of signals) {
+				if (! (signal instanceof AbortSignal)) {
+					const err = new TypeError('`signal` is not an `AbortSignal`');
+					controller.abort(err);
+					throw err;
+				} else if (signal.aborted) {
+					controller.abort(signal.reason || new DOMException('Operation aborted.'));
+					break;
+				} else {
+					signal.addEventListener('abort', ({ target }) => {
+						controller.abort(target.reason || new DOMException('Operation aborted.'));
+					}, { signal: controller.signal });
+				}
+			}
+
+			return controller.signal;
+		};
+	}
+})();

package/all.js

@@ -0,0 +1,30 @@
+/**
+ * @copyright 2023 Chris Zuber <admin@kernvalley.us>
+ */
+import './symbols.js';
+import './array.js';
+import './globalThis.js';
+import './function.js';
+import './number.js';
+import './iterator.js';
+import './math.js';
+import './secure-context.js';
+import './navigator.js';
+import './performance.js';
+import './abort.js';
+import './errors.js';
+import './match-media.js';
+import './promise.js';
+import './textEncoder.js';
+import './crypto.js';
+import './cookieStore.js';
+import './animation.js';
+import './trustedTypes.js';
+import './sanitizer.js';
+import './element.js';
+import './set.js';
+import './map.js';
+import './weakMap.js';
+import './window.js';
+import './scheduler.js';
+import './elementInternals.js';

package/animation.js

@@ -0,0 +1,33 @@
+(function() {
+	'use strict';
+
+	if (globalThis.hasOwnProperty('Animation') && ! Animation.prototype.hasOwnProperty('finished')) {
+		Object.defineProperty(Animation.prototype, 'finished', {
+			get: function() {
+				return new Promise((resolve, reject) => {
+					if (this.playState === 'finished') {
+						resolve(this);
+					} else {
+						this.addEventListener('finish', () => resolve(this), { once: true });
+						this.addEventListener('error', event => reject(event), { once: true });
+					}
+				});
+			}
+		});
+	}
+
+	if (globalThis.hasOwnProperty('Animation') && ! Animation.prototype.hasOwnProperty('ready')) {
+		Object.defineProperty(Animation.prototype, 'ready', {
+			get: function() {
+				return new Promise((resolve, reject) => {
+					if (! this.pending) {
+						resolve(this);
+					} else {
+						this.addEventListener('ready', () => resolve(this), { once: true });
+						this.addEventListener('error', event => reject(event), { once: true });
+					}
+				});
+			}
+		});
+	}
+})();

package/aom.js

@@ -0,0 +1,43 @@
+export const aria = {
+	ariaAtomic: 'aria-atomic',
+	ariaAutoComplete: 'aria-autocomplete',
+	ariaBusy: 'aria-busy',
+	ariaChecked: 'aria-checked',
+	ariaColCount: 'aria-colcount',
+	ariaColIndex: 'aria-colindex',
+	ariaColIndexText: 'aria-colindextext',
+	ariaColSpan: 'aria-colspan',
+	ariaCurrent: 'aria-current',
+	ariaDisabled: 'aria-disabled',
+	ariaExpanded: 'aria-expanded',
+	ariaHasPopup: 'aria-haspopup',
+	ariaHidden: 'aria-hidden',
+	ariaInvalid: 'aria-invalid',
+	ariaKeyShortcuts: 'aria-keyshortcuts',
+	ariaLabel: 'aria-label',
+	ariaLevel: 'aria-level',
+	ariaLive: 'aria-live',
+	ariaModal: 'aria-modal',
+	ariaMultiLine: 'aria-multiline',
+	ariaMultiSelectable: 'aria-multiselectable',
+	ariaOrientation: 'aria-orientation',
+	ariaPlaceholder: 'aria-placeholder',
+	ariaPosInSet: 'aria-posinset',
+	ariaPressed: 'aria-pressed',
+	ariaReadOnly: 'aria-readonly',
+	ariaRelevant: 'aria-relevant',
+	ariaRequired: 'aria-required',
+	ariaRoleDescription: 'aria-roledescription',
+	ariaRowCount: 'aria-rowcount',
+	ariaRowIndex: 'aria-rowindex',
+	ariaRowIndexText: 'aria-rowindextext',
+	ariaRowSpan: 'aria-rowspan',
+	ariaSelected: 'aria-selected',
+	ariaSetSize: 'aria-setsize',
+	ariaSort: 'aria-sort',
+	ariaValueMax: 'aria-valuemax',
+	ariaValueMin: 'aria-valuemin',
+	ariaValueNow: 'aria-valuenow',
+	ariaValueText: 'aria-valuetext',
+	role: 'role'
+};

package/appBadge.js

@@ -0,0 +1,27 @@
+(function() {
+	'use strict';
+
+	if (! (navigator.setAppBadge instanceof Function)) {
+		navigator.setAppBadge = async (n) => {
+			if (! Number.isInteger(n)) {
+				throw new TypeError('Failed to execute \'setAppBadge\' on \'Navigator\': Value is not of type \'unsigned long long\'');
+			} else if (n < 0) {
+				throw new TypeError('Failed to execute \'setAppBadge\' on \'Navigator\': Value is outside the \'unsigned long long\' value range.');
+			} else if (n === 0) {
+				if (document.title.startsWith('(')) {
+					document.title = document.title.replace(/^\((\d{1,2}\+?)\)\s/, '');
+				}
+			} else if (n < 100) {
+				await navigator.clearAppBadge();
+				document.title = `(${n}) ${document.title}`;
+			} else {
+				await navigator.clearAppBadge();
+				document.title = `(99+) ${document.title}`;
+			}
+		};
+	}
+
+	if (! (navigator.clearAppBadge instanceof Function)) {
+		navigator.clearAppBadge = () => navigator.setAppBadge(0);
+	}
+})();

package/array.js

@@ -0,0 +1,258 @@
+(function() {
+	'use strict';
+
+	/**
+	 * @SEE https://github.com/tc39/proposal-relative-indexing-method#polyfill
+	 * @SEE https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray
+	 */
+
+	const SHIM_TARGETS = [Array, String, globalThis.Int8Array, globalThis.Uint8Array,
+		globalThis.Uint8ClampedArray, globalThis.Int16Array, globalThis.Uint16Array,
+		globalThis.Int32Array, globalThis.Uint32Array, globalThis.Float32Array,
+		globalThis.Float64Array, globalThis.BigInt64Array, globalThis.BigUint64Array,
+	];
+
+	if (! (Array.prototype.flat instanceof Function)) {
+		Array.prototype.flat = function(depth = 1) {
+			const result = [];
+			depth = Math.min(Number.MAX_SAFE_INTEGER, Math.max(0, depth));
+
+			const flattenFn = (item, depth) => {
+				if (Array.isArray(item) && depth >= 0) {
+					item.forEach(i => flattenFn(i, depth - 1));
+				} else {
+					result.push(item);
+				}
+			};
+
+			flattenFn(this, Number.isNaN(depth) ? 0 : depth);
+			return result;
+		};
+	}
+
+	if (! (Array.prototype.flatMap instanceof Function)) {
+		Array.prototype.flatMap = function(cb, thisArg) {
+			return this.map(cb, thisArg).flat(1);
+		};
+	}
+
+	if (! (Array.prototype.findLast instanceof Function)) {
+		Array.prototype.findLast = function(callback, thisArg) {
+			let found = undefined;
+
+			this.forEach((item, index, arr) => {
+				if (callback.call(thisArg, item, index, arr)) {
+					found = item;
+				}
+			}, thisArg);
+
+			return found;
+		};
+	}
+
+	if (! (Array.prototype.findLastIndex instanceof Function)) {
+		Array.prototype.findLastIndex = function(callback, thisArg) {
+			let found = -1;
+
+			this.forEach((item, index, arr) => {
+				if (callback.call(thisArg, item, index, arr)) {
+					found = index;
+				}
+			}, thisArg);
+
+			return found;
+		};
+	}
+
+	if (! (Array.prototype.at instanceof Function)) {
+		const at = function at(n) {
+			n = Math.trunc(n) || 0;
+			if (n < 0) n += this.length;
+			if (n < 0 || n >= this.length) return undefined;
+			return this[n];
+		};
+
+		for (const C of SHIM_TARGETS) {
+			if (typeof C !== 'undefined') {
+				Object.defineProperty(C.prototype, 'at', {
+					value: at,
+					writable: true,
+					enumerable: false,
+					configurable: true
+				});
+			}
+		}
+	}
+
+	/**
+	 * @see https://github.com/tc39/proposal-array-grouping
+	 */
+	if (! (Array.prototype.group instanceof Function)) {
+		Array.prototype.group = function group(callback, thisArg = globalThis) {
+			return this.reduce((groups, item, index, arr) => {
+				const key = callback.call(thisArg, item, index, arr);
+
+				if (! groups.hasOwnProperty(key)) {
+					groups[key] = [item];
+				} else {
+					groups[key].push(item);
+				}
+
+				return groups;
+			}, {});
+		};
+	}
+
+	/**
+	 * @deprecated [renamed to `group()`]
+	 */
+	Array.prototype.groupBy = function groupBy(...args) {
+		console.warn('`goupBy` is deprecated. Please use `group` instead.');
+		return this.group(...args);
+	};
+
+	/**
+	 * @see https://github.com/tc39/proposal-array-grouping
+	 * @requires `Map.prototype.emplace`
+	 */
+	if (! (Array.prototype.groupToMap instanceof Function) && (Map.prototype.emplace instanceof Function)) {
+		Array.prototype.groupToMap = function groupToMap(callback, thisArg = globalThis) {
+			return this.reduce((map, item, index, arr) => {
+				map.emplace(callback.call(thisArg, item, index, arr), {
+					insert: () => [item],
+					update: existing => {
+						existing.push(item);
+						return existing;
+					}
+				});
+
+				return map;
+			}, new Map());
+		};
+	}
+
+	/**
+	 * @deprecated [renamed to `groupToMap()`]
+	 */
+	if (Map.prototype.emplace instanceof Function) {
+		Array.prototype.groupByToMap = function groupByToMap(...args) {
+			console.warn('`goupByToMap` is deprecated. Please use `groupToMap` instead.');
+			return this.groupToMap(...args);
+		};
+	}
+
+	/**
+	 * @see https://github.com/tc39/proposal-array-from-async
+	 */
+	if (! (Array.fromAsync instanceof Function)) {
+		Array.fromAsync = async function fromAsync(items, mapFn, thisArg = globalThis) {
+			let arr = [];
+
+			for await (const item of items) {
+				arr.push(await item);
+			}
+
+			return Array.from(arr, mapFn, thisArg);
+		};
+	}
+
+	/**
+	 * @see https://github.com/tc39/proposal-array-equality/
+	 */
+	if (! (Array.prototype.equals instanceof Function)) {
+		Array.prototype.equals = function equals(arr) {
+			if (this === arr) {
+				return true;
+			} else if (! Array.isArray(arr)) {
+				return false;
+			} else if (this.length !== arr.length) {
+				return false;
+			} else {
+				return this.every((item, i) => {
+					const val = arr[i];
+					if (Array.isArray(item)) {
+						return Array.isArray(val) && item.equals(val);
+					} else {
+						return Object.is(item, val);
+					}
+				});
+			}
+		};
+	}
+	/**
+	 * @see https://github.com/tc39/proposal-array-unique
+	 */
+	if (! (Array.prototype.uniqueBy instanceof Function)) {
+		Array.prototype.uniqueBy = function uniqueBy(arg) {
+			if (typeof arg === 'undefined') {
+				return [...new Set(this)];
+			} else if (typeof arg === 'string') {
+				const found = [];
+
+				return this.filter(obj => {
+					const key = obj[arg];
+					if (found.includes(key)) {
+						return false;
+					} else {
+						found.push(key);
+						return true;
+					}
+				});
+			} else if (arg instanceof Function) {
+				const found = [];
+
+				return this.filter((...args) => {
+					try {
+						const key = arg.apply(this, args);
+
+						if (typeof key !== 'string') {
+							return false;
+						} else if (found.includes(key)) {
+							return false;
+						} else {
+							found.push(key);
+							return true;
+						}
+					} catch(err) {
+						return false;
+					}
+				});
+			} else {
+				throw new TypeError('Not a valid argument for uniqueBy');
+			}
+		};
+	}
+
+	/**
+	 * Change Array by copy proposal
+	 * @Note: Not clear if should use `structedClone` or `[...this]` for copies
+	 * @see https://github.com/tc39/proposal-change-array-by-copy
+	 */
+	if (! (Array.prototype.toReversed instanceof Function)) {
+		Array.prototype.toReversed = function toReversed() {
+			return [...this].reverse();
+		};
+	}
+
+	if (! (Array.prototype.toSorted instanceof Function)) {
+		Array.prototype.toSorted = function toSorted(cmpFn) {
+			return [...this].sort(cmpFn);
+		};
+	}
+
+	if (! (Array.prototype.toSpliced instanceof Function)) {
+		Array.prototype.toSpliced = function toSpliced(start, deleteCount, ...items) {
+			const cpy = [...this];
+			cpy.splice(start, deleteCount, ...items);
+			return cpy;
+		};
+	}
+
+	if (! (Array.prototype.with instanceof Function)) {
+		Array.prototype.with = function (index, value) {
+			const cpy = [...this];
+			cpy[index] = value;
+			return cpy;
+		};
+	}
+})();