@shgysk8zer0/polyfills 0.0.2

package/assets/CookieStore.js

@@ -0,0 +1,230 @@
+/**
+ * @copyright 2023 Chris Zuber <admin@kernvalley.us>
+ * @SEE https://wicg.github.io/cookie-store/
+ * @SEE https://wicg.github.io/cookie-store/explainer.html
+ * @NOTE: This offers similar methods but is not a substitute and cannot get extended
+ * cookie properties, such as expires, etc.
+ *
+ * @TODO verify spec compliance as best as is possible
+ */
+
+export const nativeSupport = 'cookieStore' in globalThis;
+
+const symbols = {
+	constructor: Symbol('constructor'),
+};
+
+function getAllCookies() {
+	if (document.cookie.length === 0) {
+		return [];
+	} else {
+		return document.cookie.split(';').map(str => {
+			const [name, value = null] = str.split('=');
+			return {
+				name: decodeURIComponent(name.trim()),
+				value: typeof value === 'string' ? decodeURIComponent(value.trim()) : null,
+				path: undefined,
+				expires: undefined,
+				domain: undefined,
+				sameSite: undefined,
+				secure: undefined,
+			};
+		});
+	}
+}
+
+function defaultParams({
+	name,
+	value    = null,
+	domain   = null,
+	path     = '/',
+	expires  = null,
+	maxAge   = null,
+	sameSite = 'strict',
+	secure   = false,
+	httpOnly = false,
+}) {
+	return { name, value, domain, path, expires, maxAge, sameSite, secure, httpOnly };
+}
+
+function getter({ name = null, value = null } = {}) {
+	if (typeof name === 'string') {
+		name = decodeURIComponent(name);
+	}
+
+	if (typeof value === 'string') {
+		value = decodeURIComponent(value);
+	}
+
+	if (typeof name === 'string' && typeof value === 'string') {
+		return getAllCookies().filter((cookie) =>
+			cookie.name === name && cookie.value === value
+		);
+	} else if (typeof name === 'string') {
+		return getAllCookies().filter(cookie => cookie.name === name);
+	} else if (typeof value === 'string') {
+		return getAllCookies().filter(cookie => cookie.value === value);
+	} else {
+		return getAllCookies();
+	}
+}
+
+function setter({
+	name,
+	value,
+	expires  = null,
+	maxAge   = null,
+	path     = '/',
+	sameSite = 'strict',
+	domain   = null,
+	secure   = false,
+	httpOnly = false,
+}) {
+	if (Number.isInteger(maxAge)) {
+		setter({
+			name, value, expires: Date.now() + maxAge, path, sameSite, domain, secure, httpOnly,
+		});
+	} else {
+		let cookie = `${encodeURIComponent(name)}=`;
+
+		if (value) {
+			cookie += encodeURIComponent(value);
+		}
+
+		if (Number.isInteger(expires)) {
+			cookie += `;expires=${new Date(expires).toUTCString()}`;
+		} else if (expires instanceof Date) {
+			cookie += `;expires=${expires.toUTCString()}`;
+		}
+
+		if (typeof path === 'string') {
+			cookie += `;path=${path}`;
+		}
+
+		if (typeof domain === 'string') {
+			cookie += `;domain=${domain}`;
+		}
+
+		if (typeof sameSite === 'string') {
+			cookie += `;sameSite=${sameSite}`;
+		}
+
+		if (secure === true) {
+			cookie += ';secure';
+		}
+
+		/**
+		 * Does not work in any browser, but set regardless
+		 */
+		if (httpOnly === true) {
+			cookie += ';httponly';
+		}
+
+		document.cookie = cookie;
+	}
+}
+
+export class CookieStore extends EventTarget {
+	constructor(key) {
+		if (key !== symbols.constructor) {
+			throw new DOMException('Invalid constructor');
+		}
+
+		super();
+
+		Object.defineProperty(this, symbols.onchange, {
+			enumerable: false,
+			configurable: false,
+			writable: true,
+			value: null,
+		});
+	}
+
+	get onchange() {
+		return this[symbols.onchange];
+	}
+
+	set onchange(callback) {
+		if (this[symbols.onchange] instanceof Function) {
+			this.removeEventListener('change', this[symbols.onchange]);
+		}
+
+		if (callback instanceof Function) {
+			this.addEventListener('change', callback);
+		}
+	}
+
+	async get(args) {
+		const cookies = await this.getAll(args);
+
+		if (Array.isArray(cookies) && cookies.length !== 0) {
+			return cookies[0];
+		} else {
+			return null;
+		}
+	}
+
+	async getAll(args) {
+		if (typeof args === 'string') {
+			return getter({ name: args });
+		} else {
+			return getter(args);
+		}
+	}
+
+	async set(...args) {
+		if (args.length === 1 && typeof args[0].name === 'string') {
+			const cookie = defaultParams(args[0]);
+			setter(cookie);
+			const event = new Event('change');
+			event.changed = [cookie];
+			event.deleted = [];
+
+			this.dispatchEvent(event);
+		} else if (args.length === 2) {
+			this.set({ name: args[0], value: args[1] });
+		} else {
+			throw new Error('Invalid arguments');
+		}
+	}
+
+	async delete(args = {}) {
+		if (typeof args === 'string') {
+			this.delete({ name: args });
+		} else if (typeof args.name === 'string') {
+			const cookies = await this.getAll(args);
+
+			if (cookies.length !== 0) {
+				const event = new Event('change');
+				event.changed = [];
+				event.deleted = new Array(cookies.length);
+
+				cookies.forEach((cookie, i) => {
+					cookie.path = args.path || '/';
+					cookie.domain = args.domain || null;
+					cookie.secure = args.secure || null;
+					delete cookie.value;
+					cookie.sameSite = args.sameSite || 'strict';
+
+					event.deleted[i] = cookie;
+					setter({...cookie, value: null, expires: 1 });
+				});
+
+				this.dispatchEvent(event);
+			}
+		} else {
+			throw new TypeError('Failed to execute \'delete\' on \'CookieStore\': required member name is undefined.');
+		}
+	}
+}
+
+export const cookieStore = new CookieStore(symbols.constructor);
+
+export function polyfill() {
+	if (! nativeSupport) {
+		globalThis.cookieStore = cookieStore;
+		return true;
+	} else {
+		return false;
+	}
+}

package/assets/Lock.js

@@ -0,0 +1,31 @@
+/**
+ * @copyright 2023 Chris Zuber <admin@kernvalley.us>
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Lock
+ */
+const protectedData = new WeakMap();
+
+export class Lock {
+	constructor(name, mode = 'exclusive') {
+		if (! ['exclusive', 'shared'].includes(mode)) {
+			throw new TypeError(`'${mode}' (value of 'mode' member of LockOptions) is not a valid value for enumeration LockMode.`);
+		}
+
+		if (typeof name !== 'string') {
+			name = name.toString();
+		}
+
+		if (name.startsWith('-')) {
+			throw new DOMException('Names starting with `-` are reserved');
+		}
+
+		protectedData.set(this, { name, mode });
+	}
+
+	get name() {
+		return protectedData.get(this).name;
+	}
+
+	get mode() {
+		return protectedData.get(this).mode;
+	}
+}

package/assets/LockManager.js

@@ -0,0 +1,278 @@
+/**
+ * @copyright 2023 Chris Zuber <admin@kernvalley.us>
+ */
+import { getDeferred, isAsync } from './utility.js';
+import { Lock } from './Lock.js';
+const locks = new Map();
+const symbols = {
+	lockKey: Symbol('lock-key'),
+};
+
+export const nativeSupport = 'locks' in navigator && navigator.locks.request instanceof Function;
+export async function checkSupport() {
+	return await new Promise(resolve => {
+		if ('locks' in navigator && navigator.locks.request instanceof Function) {
+			navigator.locks.query().then(() => resolve(true)).catch(() => resolve(false));
+		} else {
+			resolve(false);
+		}
+	});
+}
+/**
+ * Some browsing contexts (iframes) have `navigator.locks` but methods only throw
+ */
+export const actuallySupported = checkSupport();
+
+async function callFunction(callback, arg = null) {
+	return new Promise((resolve, reject) => {
+		if (isAsync(callback)) {
+			callback.call(globalThis, arg).then(resolve, reject);
+		} else {
+			queueMicrotask(() => {
+				try {
+					const result = callback.call(globalThis, arg);
+					resolve(result);
+				} catch(err) {
+					reject(err);
+				}
+			});
+		}
+	});
+}
+
+function shouldPend({ name, mode }) {
+	switch(mode) {
+		case 'exclusive': return getLocks().some(lock => lock.name === name);
+		case 'shared': return getLocks().some(lock => lock.name === name && lock.mode === 'exclusive');
+	}
+}
+
+function stealLocks(name) {
+	[...locks.entries()].filter(([lock]) => lock.name === name).forEach(([lock, { reject, controller }]) => {
+		requestIdleCallback(() => {
+			controller.abort();
+			locks.delete(lock);
+		});
+		reject(new DOMException('The lock request is aborted'));
+	});
+}
+
+async function whenReleased(lock) {
+	if (locks.has(lock)) {
+		await locks.get(lock).promise.catch(console.error);
+	}
+}
+
+function queueTask(name, mode, callback) {
+	const { resolve, reject, promise } = getDeferred();
+	const controller = new AbortController();
+	const lock = new Lock(name, mode);
+	const pending = shouldPend(lock);
+	locks.set(lock, { resolve, reject, promise, callback, pending, controller });
+	return lock;
+}
+
+function setPending(lock, pending = true) {
+	if (locks.has(lock)) {
+		locks.set(lock, {...locks.get(lock), pending });
+	}
+}
+
+function isPending(lock) {
+	return lock instanceof Lock && locks.has(lock) && locks.get(lock).pending;
+}
+
+function getLocks(name) {
+	if (typeof name === 'string') {
+		return [...locks.keys()].filter(lock => lock.name === name);
+	} else {
+		return [...locks.keys()];
+	}
+}
+
+function getHeldLocks(name) {
+	return getLocks(name).filter(lock => ! isPending(lock));
+}
+
+function getPendingLocks(name) {
+	return getLocks(name).filter(lock => isPending(lock));
+}
+
+async function whenNotBlocked(lock) {
+	switch(lock.mode) {
+		case 'exclusive':
+			await Promise.allSettled(getLocks()
+				.filter(l => l.name === lock.name && l !== lock).map(whenReleased));
+			break;
+		case 'shared':
+			await Promise.allSettled(getLocks()
+				.filter(l => l.name === lock.name && l.mode === 'exclusive' && l !== lock).map(whenReleased));
+			break;
+	}
+}
+
+function getLockSignal(lock) {
+	if (locks.has(lock)) {
+		return locks.get(lock).controller.signal;
+	}
+}
+
+async function executeLock(lock) {
+	if (locks.has(lock)) {
+		const { resolve, reject, promise, callback, pending, controller } = locks.get(lock);
+		if (pending) {
+			setPending(lock, false);
+		}
+
+		callFunction(callback, lock).then(resolve, reject).finally(() => {
+			locks.delete(lock);
+			requestIdleCallback(() => controller.abort());
+		});
+
+		return promise;
+	}
+}
+
+/**
+ * @see https://w3c.github.io/web-locks/
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/LockManager
+ */
+export class LockManager {
+	constructor(key) {
+		if (key !== symbols.lockKey) {
+			throw new TypeError('Invalid constructor');
+		}
+	}
+	/**
+	 * @see https://developer.mozilla.org/en-US/docs/Web/API/LockManager/request
+	 * @param  {[type]}  name               [description]
+	 * @param  {[type]}  args               [description]
+	 * @return {Promise}      [description]
+	 * static async request(name, callback)
+	 * static async request(name, { mode = 'exclusive', ifAvailable = false, steal = false, signal }, callback)
+	 */
+	static async request(name, ...args) {
+		let opts = {}, callback;
+		if (args[0] instanceof Function) {
+			callback = args[0];
+		} else if (args[1] instanceof Function) {
+			[opts, callback] = args;
+		}
+
+		if (typeof name !== 'string') {
+			name = name.toString();
+		}
+
+		const { mode = 'exclusive', ifAvailable = false, steal = false, signal } = opts;
+
+		if (steal && ifAvailable) {
+			throw new DOMException('LockManager.request: `steal` and `ifAvailable` cannot be used together');
+		} else if (name.startsWith('-')) {
+			throw new DOMException('LockManager.request: Names starting with `-` are reserved');
+		} else if (! ['exclusive', 'shared'].includes(mode)) {
+			throw new TypeError(`LockManager.request: '${mode}' (value of 'mode' member of LockOptions) is not a valid value for enumeration LockMode.`);
+		} else if (signal instanceof AbortSignal && signal.aborted) {
+			throw signal.reason;
+		} else if (mode === 'shared' && steal) {
+			throw new DOMException('LockManager.request: `steal` is only supported for exclusive lock requests');
+		}
+
+		const held = getHeldLocks(name);
+		const pending = getPendingLocks(name);
+		const alreadyLocked = [...held, ...pending].some(lock => lock.name === name);
+
+		if (steal && alreadyLocked) {
+			stealLocks(name);
+		}
+
+		/**
+		 * If shared & held lock found (none exclusive), then this lock may be held as well
+		 * If exclusive & held or pending lock found, this is pending
+		 */
+		const lock = queueTask(name, mode, callback);
+		if (signal instanceof AbortSignal) {
+			signal.addEventListener('abort', () => {
+				if (locks.has(lock)) {
+					const { reject, controller } = locks.get(lock);
+					locks.delete(lock);
+					reject(new DOMException('The lock request is aborted'));
+					controller.abort();
+				}
+			}, { once: true, signal: getLockSignal(lock) });
+		}
+
+		switch(mode) {
+			case 'exclusive': {
+				if (ifAvailable && (held.length !== 0 || pending.length !== 0)) {
+					const controller = locks.get(lock).controller;
+					locks.delete(lock);
+					return await callFunction(callback, null).then(result => {
+						requestIdleCallback(() => controller.abort());
+						return result;
+					});
+				} else {
+					await whenNotBlocked(lock);
+					return await executeLock(lock);
+				}
+			}
+
+			case 'shared': {
+				if (! ifAvailable) {
+					await whenNotBlocked(lock);
+					return await executeLock(lock);
+				} else if ([...held, ...pending].some(lock => lock.mode === 'exclusive')) {
+					const controller = locks.get(lock).controller;
+					locks.delete(lock);
+					return await callFunction(callback, null).then(result => {
+						requestIdleCallback(() => controller.abort());
+						return result;
+					});
+				} else {
+					await whenNotBlocked(lock);
+					return await executeLock(lock);
+				}
+			}
+
+			default:
+				throw new TypeError(`LockManager.request: '${mode}' (value of 'mode' member of LockOptions) is not a valid value for enumeration LockMode.`);
+		}
+	}
+
+	/**
+	 * @see https://developer.mozilla.org/en-US/docs/Web/API/LockManager/query
+	 * @return {Promise} { held: [], pending: [] }
+	 */
+	static async query() {
+		return {
+			held: getHeldLocks().map(({ name, mode }) => ({ name, mode, clientId: null })),
+			pending: getPendingLocks().map(({ name, mode }) => ({ name, mode, clientId: null })),
+		};
+	}
+}
+
+export async function request(...args) {
+	if (await actuallySupported) {
+		return navigator.locks.request(...args);
+	} else {
+		return LockManager.request(...args);
+	}
+}
+
+export async function query() {
+	if (await actuallySupported) {
+		return navigator.locks.query();
+	} else {
+		return LockManager.query();
+	}
+}
+
+export async function polyfill() {
+	if (! nativeSupport) {
+		globalThis.Lock = Lock;
+		globalThis.LockManager = LockManager;
+		navigator.locks = LockManager;
+	} else if (! await actuallySupported) {
+		navigator.locks.request = (...args) => LockManager.request(...args);
+		navigator.locks.query = () => LockManager.query();
+	}
+}

package/assets/Sanitizer.js

@@ -0,0 +1,59 @@
+/**
+ * @copyright 2022-2023 Chris Zuber <admin@kernvalley.us>
+ */
+import { nativeSupport, getSantizerUtils, sanitize, sanitizeFor, trustPolicies } from './sanitizerUtils.js';
+import { SanitizerConfig as defaultConfig } from './SanitizerConfigW3C.js';
+
+const protectedData = new WeakMap();
+
+/**
+ * Need to create a policy for the Sanitizer API since
+ * `trustedTypes.defaultPolicy.createHTML` will most likely use `new Sanitizer().sanitize()`
+ * which would create infinite recursion.
+ * @type {TrustedTypePolicy}
+ */
+
+
+/**
+ * @SEE https://wicg.github.io/sanitizer-api/
+ * @SEE https://developer.mozilla.org/en-US/docs/Web/API/Sanitizer/Sanitizer
+ * @TODO: Figure out how to handle `allowElements`, `allowAttributes`, and how each
+ *        works with their `block*` and/or `drop*` counterparts.
+ * @TODO: Handle `svg:*` and `mathml:*`
+ *
+ * @NOTE: The spec is still under development and is likely to change.
+ * @NOTE: This is a very imperfect implementation and may not perform very well,
+ *        as it may involve a lot of querying & modifying.
+ */
+export class Sanitizer {
+	constructor({
+		allowElements, allowAttributes, blockElements, dropAttributes,
+		dropElements, allowComments = defaultConfig.allowComments,
+		allowCustomElements = defaultConfig.allowCustomElements,
+		allowUnknownMarkup = defaultConfig.allowUnknownMarkup,
+	} = Sanitizer.getDefaultConfiguration()) {
+		protectedData.set(this, {
+			allowElements, allowComments, allowAttributes, allowCustomElements,
+			blockElements, dropAttributes, dropElements, allowUnknownMarkup,
+		});
+	}
+
+	getConfiguration() {
+		return protectedData.get(this);
+	}
+
+	sanitize(input) {
+		return sanitize(input, { config: this.getConfiguration() });
+	}
+
+	sanitizeFor(tag, content) {
+		return sanitizeFor(tag, content, { config: this.getConfiguration() });
+	}
+
+	static getDefaultConfiguration() {
+		return defaultConfig;
+	}
+}
+
+const { setHTML, polyfill } = getSantizerUtils(Sanitizer, defaultConfig);
+export { nativeSupport, setHTML, polyfill, trustPolicies };