@shgysk8zer0/polyfills 0.0.2

package/assets/Scheduler.js

@@ -0,0 +1,124 @@
+/**
+ * @copyright 2023 Chris Zuber <admin@kernvalley.us>
+ */
+export const PRIORITIES = {
+	blocking: 'user-blocking',
+	visible: 'user-visible',
+	background: 'background',
+};
+
+async function delayCallback(cb, { delay = 0, signal } = {}) {
+	return new Promise((resolve, reject) => {
+		if (signal instanceof AbortSignal && signal.aborted) {
+			reject(signal.reason);
+		} else {
+			const controller = new AbortController();
+			const handle = setTimeout(() => {
+				resolve(cb());
+				controller.abort();
+			}, delay);
+
+			if (signal instanceof AbortSignal) {
+				signal.addEventListener('abort', ({ target }) => {
+					reject(target.reason);
+					clearTimeout(handle);
+				}, { once: true, signal: controller.signal });
+			}
+		}
+	});
+}
+
+export class Scheduler {
+	async postTask(callback, {
+		priority = PRIORITIES.visible,
+		delay,
+		signal,
+	} = {}) {
+		return new Promise((resolve, reject) => {
+			if (signal instanceof AbortSignal && signal.aborted) {
+				reject(signal.reason);
+			} else {
+				switch(priority) {
+					case PRIORITIES.blocking:
+						if (typeof delay === 'number' && ! Number.isNaN(delay) && delay > 0) {
+							delayCallback(callback, { delay, signal })
+								.then(resolve, reject);
+						} else {
+							resolve((async () => await callback())());
+						}
+
+						break;
+
+					case PRIORITIES.visible:
+						if (typeof delay === 'number' && ! Number.isNaN(delay) && delay > 0) {
+							delayCallback(() => requestAnimationFrame(async () => {
+								try {
+									const result = await callback();
+									resolve(result);
+								} catch(err) {
+									reject(err);
+								}
+							}), { delay, signal }).catch(reject);
+						} else {
+							const controller = new AbortController();
+							const handle = requestAnimationFrame(async () => {
+								try {
+									const result = await callback();
+									resolve(result);
+								} catch(err) {
+									reject(err);
+								} finally {
+									controller.abort();
+								}
+							});
+
+							if (signal instanceof AbortSignal) {
+								signal.addEventListener('abort', ({ target }) => {
+									cancelAnimationFrame(handle);
+									reject(target.reason);
+								}, { once: true, signal: controller.signal });
+							}
+						}
+
+						break;
+
+					case PRIORITIES.background:
+						if (typeof delay === 'number' && ! Number.isNaN(delay) && delay > 0) {
+							delayCallback(() => requestIdleCallback(async () => {
+								try {
+									const result = await callback();
+									resolve(result);
+								} catch(err) {
+									reject(err);
+								}
+							}), { delay, signal }).catch(reject);
+						} else {
+							const controller = new AbortController();
+							const handle = requestIdleCallback(async () => {
+								try {
+									const result = await callback();
+									resolve(result);
+								} catch(err) {
+									reject(err);
+								} finally {
+									controller.abort();
+								}
+							});
+
+							if (signal instanceof AbortSignal) {
+								signal.addEventListener('abort', ({ target }) => {
+									cancelIdleCallback(handle);
+									reject(target.reason);
+								}, { once: true, signal: controller.signal });
+							}
+						}
+
+						break;
+
+					default:
+						throw new TypeError(`Scheduler.postTask: '${priority}' (value of 'priority' member of SchedulerPostTaskOptions) is not a valid value for enumeration TaskPriority.`);
+				}
+			}
+		});
+	}
+}

package/assets/TextDecoder.js

@@ -0,0 +1,83 @@
+/**
+ * @copyright 2023 Chris Zuber <admin@kernvalley.us>
+ */
+import { between } from './utility.js';
+/**
+ *
+ * Array of supported encodings
+ * @Todo: At least add utf-16
+ * @type {Array}
+ */
+const supportedEncodings = ['utf-8', 'utf8'];
+
+export const BOM = new Uint8Array([0xEF, 0xBB, 0xBF]);
+
+export class TextDecoder {
+	constructor(encoding = 'utf-8', { fatal = false, ignoreBOM = false } = {}) {
+		if (typeof encoding !== 'string') {
+			encoding = encoding.toString().toLowerCase();
+		} else {
+			encoding = encoding.toLowerCase();
+		}
+
+		if (! supportedEncodings.includes(encoding)) {
+			throw new RangeError(`TextDecoder constructor: The given encoding '${encoding}' is not supported.`);
+		}
+
+		Object.defineProperties(this, {
+			encoding: {
+				configurable: false,
+				enumerable: true,
+				writable: false,
+				value: encoding,
+			},
+			fatal: {
+				configurable: false,
+				enumerable: true,
+				writable: false,
+				value: fatal,
+			},
+			ignoreBOM: {
+				configurable: false,
+				enumerable: true,
+				writable: false,
+				value: ignoreBOM,
+			},
+		});
+	}
+
+	decode(data) {
+		switch(this.encoding) {
+			case 'utf-8':
+			case 'utf8': {
+				let prev = NaN;
+				/**
+				 * For (0,127) we just take the charCode
+				 * For charCode 128+this will be in the form [n=194+, m=(128-191)]
+				 * where n increments after m reaches 191, increments, and rolls back to 128
+				 */
+				return data.reduce((str, i, n) => {
+					if (Number.isNaN(prev) && i < 128) {
+						return str + String.fromCharCode(i);
+					} else if (Number.isNaN(prev) && i > 193) {
+						prev = i;
+						return str;
+					} else if (prev > 193 && between(128, i, 194)) {
+						const offset = (prev - 194) * 64;
+						prev = NaN;
+						return str + String.fromCharCode(offset + i);
+					} else if (this.fatal) {
+						throw new RangeError(`Unhandled character at postion ${n}`);
+					} else {
+						prev = NaN;
+						return str;
+					}
+				}, '');
+
+			}
+
+			default:
+				throw new TypeError(`Unsupported encoding '${this.encoding}'`);
+		}
+	}
+}

package/assets/TextEncoder.js

@@ -0,0 +1,41 @@
+/**
+ * @copyright 2023 Chris Zuber <admin@kernvalley.us>
+ */
+export class TextEncoder {
+	get encoding() {
+		return 'utf-8';
+	}
+
+	encode(str) {
+		// Identical to char up to 127, then [194, (n)] for n=(128-191),
+		// then [194, (128-191)] for n=(192-255)
+		// and it looks like this holds in intervals of 64
+		return new Uint8Array(str.split('').flatMap(char => {
+			const code = char.charCodeAt(0);
+
+			if (code < 128) {
+				return [code];
+			} else {
+				const pt = 194 + Math.floor((code - 128) / 64);
+				return [pt, (code % 64) + 128];
+			}
+		}));
+	}
+
+	encodeInto(str, ui8arr) {
+		if (! (ui8arr instanceof Uint8Array)) {
+			throw new TypeError('TextEncoder.encodeInto: Argument 2 does not implement interface Uint8Array.');
+		} else {
+			const encoded = this.encode(str);
+			const len = Math.min(ui8arr.length, encoded.length);
+
+			if (encoded.length > ui8arr.length) {
+				ui8arr.set(encoded.slice(0, len));
+			} else {
+				ui8arr.set(encoded);
+			}
+
+			return { read: len, written: len };
+		}
+	}
+}