@shgysk8zer0/polyfills 0.0.2

package/math.js

@@ -0,0 +1,69 @@
+(function() {
+	'use strict';
+
+	if (! Number.hasOwnProperty('isSafeInteger')) {
+		Number.MAX_SAFE_INTEGER = 2**53 -1;
+		Number.MIN_SAFE_INTEGER = -Number.MAX_SAFE_INTEGER;
+		Number.isSafeInteger = num => num <= Number.MAX_SAFE_INTEGER && num >= Number.MIN_SAFE_INTEGER;
+	}
+
+	if (! Number.hasOwnProperty('EPSILON')) {
+		Number.EPSILON = 2**-52;
+	}
+
+	if (! Math.hasOwnProperty('sign')) {
+		Math.sign = x => ((x > 0) - (x < 0)) || +x;
+	}
+
+	if (! Math.hasOwnProperty('trunc')) {
+		Math.trunc = x => {
+			const n = x - x%1;
+			return n===0 && (x<0 || (x===0 && (1/x !== 1/0))) ? -0 : n;
+		};
+	}
+
+	if (! Math.hasOwnProperty('expm1')) {
+		Math.expm1 = x => Math.exp(x) - 1;
+	}
+
+	if (! Math.hasOwnProperty('hypot')) {
+		Math.hypot = (...nums) => Math.sqrt(nums.reduce((sum, num) => sum +  num**2, 0));
+	}
+
+	if (! Math.hasOwnProperty('cbrt')) {
+		Math.cbrt = x => x**(1/3);
+	}
+
+	if (! Math.hasOwnProperty('log10')) {
+		Math.log10 = x => Math.log(x) * Math.LOG10E;
+	}
+
+	if (! Math.hasOwnProperty('log2')) {
+		Math.log2 = x => Math.log(x) * Math.LOG2E;
+	}
+
+	if (! Math.hasOwnProperty('log1p')) {
+		Math.log1p = x => Math.log(1 + x);
+	}
+
+	if (! Math.hasOwnProperty('fround')) {
+		Math.fround = (function (array) {
+			return function(x) {
+				return array[0] = x, array[0];
+			};
+		})(new Float32Array(1));
+	}
+
+	if (! (Math.clamp instanceof Function)) {
+		Math.clamp = function(value, min, max) {
+			return Math.min(Math.max(value, min), max);
+		};
+	}
+
+	/*
+	 * Question of if it will be `Math.clamp` or `Math.constrain`
+	 */
+	if (! (Math.constrain instanceof Function)) {
+		Math.constrain = Math.clamp;
+	}
+})();

package/navigator.js

@@ -0,0 +1,55 @@
+import './locks.js';
+import './share.js';
+import './appBadge.js';
+
+if (! Navigator.prototype.hasOwnProperty('pdfViewerEnabled')) {
+	Object.defineProperty(navigator, 'pdfViewerEnabled', {
+		enumerable: true,
+		configurable: false,
+		writable: false,
+		value: false,
+	});
+}
+
+if (! (Navigator.prototype.getInstalledRelatedApps instanceof Function)) {
+	Navigator.prototype.getInstalledRelatedApps = async () => [];
+}
+
+if (! (Navigator.prototype.getGamepads instanceof Function)) {
+	Navigator.prototype.getGamepads = () => [];
+}
+
+if (! ('hardwareConcurrency' in Navigator.prototype)) {
+	Object.defineProperty(Navigator.prototype, 'hardwareConcurrency', {
+		get: () => 1,
+	});
+}
+
+if (! ('connection' in Navigator.prototype)) {
+	Object.defineProperty(Navigator.prototype, 'connection', {
+		get: () => Object.create(EventTarget.prototype, {
+			type: { value: 'unknown' },
+			effectiveType: { value: '4g' },
+			rtt: { value: NaN },
+			downlink: { value: NaN },
+			downlinkMax: { value: Infinity },
+			saveData: { value: false },
+			onchange: { value: null, writable: true },
+			ontypechange: { value: null, writable: true },
+		})
+	});
+} else if (! ('type' in navigator.connection)) {
+	navigator.connection.type = 'unknown';
+}
+
+if (! ('doNotTrack' in Navigator.prototype)) {
+	Object.defineProperty(Navigator.prototype, 'doNotTrack', {
+		get: () => 'unspecified',
+	});
+}
+
+if (! ('globalPrivacyControl' in Navigator.prototype)) {
+	Object.defineProperty(Navigator.prototype, 'globalPrivacyControl', {
+		get: () => false,
+	});
+}

package/number.js

@@ -0,0 +1,14 @@
+(function() {
+	'use strict';
+
+	if (! (Number.range instanceof Function)) {
+		/**
+		 * @see https://github.com/tc39/proposal-Number.range
+		 * @deprecated - changed to `Iterator.range`
+		 */
+		Number.range = function range(start, end, step = 1) {
+			console.warn('`Number.range()` is deprecated. Use `Iterator.range()` instead.');
+			return globalThis.Iterator.range(start, end, { step });
+		};
+	}
+})();

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@shgysk8zer0/polyfills",
+  "version": "0.0.2",
+  "private": false,
+  "description": "A collection of JavaScript polyfills",
+  "config": {
+    "serve": {
+      "domain": "localhost",
+      "path": "./",
+      "port": 8080
+    },
+    "dir": {
+      "css": "css/ components/",
+      "js": "js/ components/",
+      "img": "img/",
+      "html": "components/"
+    }
+  },
+  "scripts": {
+    "test": "npm run lint:js && npm run lint:html",
+    "preversion": "npm test",
+    "start": "http-server ${npm_package_config_serve_path} -c-1 --port ${npm_package_config_serve_port} --gzip true --brotli true -a ${npm_package_config_serve_domain} -o /test/",
+    "fix": "npm run fix:js",
+    "fix:js": "eslint . --fix",
+    "lint:js": "eslint .",
+    "lint:html": "htmlhint \"**/*.html\"",
+    "create:lock": "npm i --package-lock-only --ignore-scripts",
+    "version:bump": "npm run version:bump:patch",
+    "version:bump:patch": "npm version --no-git-tag-version patch",
+    "version:bump:minor": "npm version --no-git-tag-version minor",
+    "version:bump:major": "npm version --no-git-tag-version major"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/shgysk8zer0/polyfills.git"
+  },
+  "keywords": [
+    "polyfills",
+    "shims"
+  ],
+  "author": "Chris Zuber <shgysk8zer0@gmail.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/shgysk8zer0/polyfills/issues"
+  },
+  "homepage": "https://github.com/shgysk8zer0/polyfills#readme",
+  "devDependencies": {
+    "eslint": "^8.40.0",
+    "htmlhint": "^1.1.4",
+    "http-server": "^14.1.1"
+  }
+}

package/performance.js

@@ -0,0 +1,36 @@
+(function() {
+	'use strict';
+
+	if (! (globalThis.requestIdleCallback instanceof Function)) {
+		const isValidTimeout = timeout => Number.isSafeInteger(timeout) && timeout > 0;
+
+		globalThis.requestIdleCallback = function(callback, { timeout } = {}) {
+			const start = performance.now();
+			const timeRemaining = () => isValidTimeout(timeout)
+				? Math.max(0, timeout - (performance.now() - start))
+				: Math.max(0, 600 - (performance.now() - start));
+
+			return setTimeout(() => callback({
+				didTimeout: isValidTimeout(timeout) ? timeRemaining() === 0 : false,
+				timeRemaining,
+			}), 1);
+		};
+	}
+
+	if (! (globalThis.cancelIdleCallback instanceof Function)) {
+		globalThis.cancelIdleCallback = id => clearTimeout(id);
+	}
+
+	if (! (globalThis.requestAnimationFrame instanceof Function)) {
+		globalThis.requestAnimationFrame = callback => setTimeout(() => callback(performance.now()), 1000 / 60);
+	}
+
+	if (! (globalThis.cancelAnimationFrame instanceof Function)) {
+		globalThis.cancelAnimationFrame = id => clearTimeout(id);
+	}
+
+	if (! (globalThis.queueMicrotask instanceof Function)) {
+		globalThis.queueMicrotask = cb => Promise.resolve().then(cb)
+			.catch(e => setTimeout(() => { throw e; }));
+	}
+})();

package/promise.js

@@ -0,0 +1,70 @@
+if ('Promise' in globalThis) {
+	if (! (Promise.prototype.finally instanceof Function)) {
+		Promise.prototype.finally = function(callback) {
+			return this.then(async val => {
+				await callback();
+				return val;
+			}, async val => {
+				await callback();
+				return val;
+			});
+		};
+	}
+
+	if (! (Promise.allSettled instanceof Function)) {
+		Promise.allSettled = function(promises) {
+			return Promise.all(Array.from(promises).map(function(call) {
+				return new Promise(function(resolve) {
+					if (! (call instanceof Promise)) {
+						call = Promise.resolve(call);
+					}
+					call.then(function(value) {
+						resolve({ status: 'fulfilled', value: value });
+					}).catch(function(reason) {
+						resolve({ status: 'rejected', reason: reason });
+					});
+				});
+			}));
+		};
+	}
+
+	if (! (Promise.any instanceof Function)) {
+		Promise.any = (promises) => new Promise((resolve, reject) => {
+			let errors = [];
+
+			promises.forEach(promise => {
+				promise.then(resolve).catch(e => {
+					errors.push(e);
+					if (errors.length === promises.length) {
+						reject(new globalThis.AggregateError(errors, 'No Promise in Promise.any was resolved'));
+					}
+				});
+			});
+		});
+	}
+
+	if (! (Promise.race instanceof Function)) {
+		Promise.race = (promises) => new Promise((resolve, reject) => {
+			promises.forEach(promise => promise.then(resolve, reject));
+		});
+	}
+
+	if (! (Promise.try instanceof Function)) {
+		/**
+		 * @see https://github.com/tc39/proposal-promise-try
+		 */
+		Promise.try = callback => new Promise(resolve => resolve(callback()));
+	}
+
+	if (! (Promise.withResolvers instanceof Function)) {
+		Promise.withResolvers = function() {
+			const def = {};
+			def.promise = new Promise((resolve, reject) => {
+				def.resolve = resolve;
+				def.reject = reject;
+			});
+
+			return def;
+		};
+	}
+}

package/sanitizer.js

@@ -0,0 +1,3 @@
+import { polyfill, trustPolicies } from './assets/Sanitizer.js';
+export const polyfilled = polyfill();
+export { trustPolicies };

package/scheduler.js

@@ -0,0 +1,5 @@
+import { Scheduler } from './assets/Scheduler.js';
+
+if (! ('scheduler' in globalThis)) {
+	globalThis.scheduler = new Scheduler();
+}

package/secure-context.js

@@ -0,0 +1,31 @@
+(function() {
+	'use strict';
+
+	if (! ('isSecureContext' in globalThis)) {
+		const hostnames = ['localhost', '127.0.0.1'];
+		const HTTPS = 'https:';
+		const protocols = [HTTPS, 'file:', 'wss:'];
+		const hasSecureScripts = (document = globalThis.document) => {
+			return [...document.scripts].every(({ src }) => {
+				if (src.length === 0) {
+					return true;
+				} else {
+					const { protocol, hostname } = new URL(src, document.baseURI);
+					return protocol === HTTPS || hostname === location.hostname;
+				}
+			});
+		};
+
+		Object.defineProperty(globalThis, 'isSecureContext', {
+			enumerable: true,
+			configurable: true,
+			get: function isSecureContext() {
+				if (protocols.includes(location.protocol) || hostnames.includes(location.hostname)) {
+					return hasSecureScripts();
+				} else {
+					return false;
+				}
+			}
+		});
+	}
+})();

package/set.js

@@ -0,0 +1,73 @@
+(function() {
+	'use strict';
+
+	/**
+	 * @see https://github.com/tc39/proposal-set-methods
+	 */
+
+	if (! (Set.prototype.intersection instanceof Function)) {
+		Set.prototype.intersection = function intersection(iterable) {
+			if (! (iterable instanceof Set)) {
+				iterable = new Set(iterable);
+			}
+
+			return new Set([...this].filter(item => iterable.has(item)));
+		};
+	}
+
+	if (! (Set.prototype.difference instanceof Function)) {
+		Set.prototype.difference = function difference(iterable) {
+			if (! (iterable instanceof Set)) {
+				iterable = new Set(iterable);
+			}
+
+			return new Set([...this].filter(item => ! iterable.has(item)));
+		};
+	}
+
+	if (! (Set.prototype.union instanceof Function)) {
+		Set.prototype.union = function union(iterable) {
+			return new Set([...this, ...iterable]);
+		};
+	}
+
+	if (! (Set.prototype.isSubsetOf instanceof Function)) {
+		Set.prototype.isSubsetOf = function isSubsetOf(iterable) {
+			if (! (iterable instanceof Set)) {
+				iterable = new Set(iterable);
+			}
+
+			return [...this].every(item => iterable.has(item));
+		};
+	}
+
+	if (! (Set.prototype.isSupersetOf instanceof Function)) {
+		Set.prototype.isSupersetOf = function isSupersetOf(iterable) {
+			if (! (iterable instanceof Set)) {
+				iterable = new Set(iterable);
+			}
+
+			return iterable.isSubsetOf(this);
+		};
+	}
+
+	if (! (Set.prototype.symmetricDifference instanceof Function)) {
+		Set.prototype.symmetricDifference = function symmetricDifference(iterable) {
+			if (! (iterable instanceof Set)) {
+				iterable = new Set(iterable);
+			}
+
+			return new Set([...this.difference(iterable), ...iterable.difference(this)]);
+		};
+	}
+
+	if (! (Set.prototype.isDisjointFrom instanceof Function)) {
+		Set.prototype.isDisjointFrom = function isDisjointFrom(iterable) {
+			if (! (iterable instanceof Set)) {
+				iterable = new Set(iterable);
+			}
+
+			return new Set([...this, ...iterable]).size === this.size + iterable.size;
+		};
+	}
+})();

package/share.js

@@ -0,0 +1,17 @@
+(function() {
+	'use strict';
+
+	if (! (navigator.canShare instanceof Function)) {
+		navigator.canShare = function({ title, text, url, files } = {}) {
+			if (! (navigator.share instanceof Function)) {
+				return false;
+			} else if (Array.isArray(files) && files.length !== 0) {
+				return false;
+			} else if ([title, text, url].every(arg => typeof arg === 'undefined')) {
+				return true;
+			} else {
+				return [title, text, url].some(arg => typeof arg === 'string' && arg.length !== 0);
+			}
+		};
+	}
+})();

package/symbols.js

@@ -0,0 +1,9 @@
+if ('Symbol' in globalThis) {
+	if (typeof Symbol.toStringTag === 'undefined') {
+		Symbol.toStringTag = Symbol('Symbol.toStringTag');
+	}
+
+	if (typeof Symbol.iterator === 'undefined') {
+		Symbol.iterator = Symbol('Symbol.iterator');
+	}
+}

package/textEncoder.js

@@ -0,0 +1,16 @@
+import { TextEncoder } from './assets/TextEncoder.js';
+import { TextDecoder } from './assets/TextDecoder.js';
+
+if (! ('TextEncoder' in globalThis)) {
+	globalThis.TextEncoder = TextEncoder;
+}
+
+if (! ('TextDecoder' in globalThis)) {
+	globalThis.TextDecoder = TextDecoder;
+}
+
+if (! (globalThis.TextEncoder.prototype.encodeInto instanceof Function)) {
+	globalThis.TextEncoder.prototype.encodeInto = function(...args) {
+		return TextEncoder.prototype.encodeInto.apply(this, args);
+	};
+}

package/trustedTypes.js

@@ -0,0 +1,3 @@
+import { polyfill, trustPolicies } from './assets/TrustedTypes.js';
+const polyfilled = polyfill();
+export { trustPolicies, polyfilled };

package/weakMap.js

@@ -0,0 +1,28 @@
+(function() {
+	'use strict';
+
+	if (! (WeakMap.prototype.emplace instanceof Function)) {
+		WeakMap.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, existing);
+				}
+
+				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/window.js

@@ -0,0 +1,85 @@
+(function() {
+	'use strict';
+
+	if ('screen' in globalThis && ! (globalThis.getScreenDetails instanceof Function)) {
+		class ScreenDetailed extends EventTarget {
+			get availHeight() {
+				return screen.availHeight;
+			}
+
+			get availLeft() {
+				return screen.availLeft;
+			}
+
+			get availTop() {
+				return screen.availTop;
+			}
+
+			get availWidth() {
+				return screen.availWidth;
+			}
+
+			get colorDepth() {
+				return screen.colorDepth;
+			}
+
+			get devicePixelRatio() {
+				return globalThis.devicePixelRatio || 1;
+			}
+
+			get height() {
+				return screen.height;
+			}
+
+			get isExtended() {
+				return screen.isExtended;
+			}
+
+			get isInternal() {
+				return true;
+			}
+
+			get isPrimary() {
+				return true;
+			}
+
+			get label() {
+				return 'Unknown';
+			}
+
+			get orientation() {
+				return screen.orientation;
+			}
+
+			get pixelDepth() {
+				return screen.pixelDepth;
+			}
+
+			get top() {
+				return screen.top;
+			}
+
+			get width() {
+				return screen.width;
+			}
+		}
+
+		class ScreenDetails extends EventTarget {
+			get currentScreen() {
+				return new ScreenDetailed();
+			}
+
+			get screens() {
+				return [this.currentScreen];
+			}
+		}
+
+		Object.defineProperty(Screen.prototype, 'isExtended', {
+			enumerable: true,
+			configurable: true,
+			get: () => false,
+		});
+
+		globalThis.getScreenDetails = async () => new ScreenDetails();
+	}
+})();