@shgysk8zer0/polyfills 0.2.8 → 0.3.0

package/CHANGELOG.md

@@ -6,6 +6,20 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [v0.3.0] - 2024-01-06
+
+### Added
+- Implement `Iterator.from`
+
+### Changed
+- Use iterators instead of generators iterator helper methods
+- Update Set to conform to spec changes
+
+## [v0.2.9] - 2023-12-10
+
+### Fixed
+- Fix misc issues with `Record` and `Tuple`
+
 ## [v0.2.8] - 2023-12-10
 
 ### Added

package/Record.js

@@ -1,6 +1,10 @@
 if (! (globalThis.Record instanceof Function)) {
 	/* eslint-disable no-inner-declarations */
 	function Record(obj) {
+		if (new.target === Record) {
+			throw new TypeError('Record is not a constructor');
+		}
+
 		const record = Object.create(Record.prototype);
 		Object.defineProperties(record, Object.fromEntries(Object.entries(obj).map(([key, value]) => [
 			key, {
@@ -15,10 +19,16 @@ if (! (globalThis.Record instanceof Function)) {
 		return record;
 	}
 
-	Record.prototype = { constructor: Record };
+	Record.prototype.constructor  = Record;
+	Object.defineProperty(Record.prototype, Symbol.toStringTag, {
+		value: 'Record',
+		enumerable: true,
+		configurable: false,
+		writable: false,
+	});
 
 	Record.fromEntries = function fromEntries(entries) {
-		return new Record(Object.fromEntries(entries));
+		return Record(Object.fromEntries(entries));
 	};
 
 	globalThis.Record = Record;

package/Tuple.js

@@ -1,104 +1,130 @@
 if (! (globalThis.Tuple instanceof Function)) {
 	/* eslint-disable no-inner-declarations */
+
+	/**
+	 * Creates an unfrozen Tuple, such as for `Tuple.of()`
+	 */
+	const createTuple = items => {
+		const tuple = Array.apply(Object.create(Tuple.prototype), items);
+		Object.setPrototypeOf(tuple, Tuple.prototype);
+		return tuple;
+	};
+
 	function Tuple(...items) {
-		const result = Array.apply(Object.create(Tuple.prototype), items);
-		Object.setPrototypeOf(result, Tuple.prototype);
-		Object.freeze(result);
-		return result;
+		if (new.target === Tuple) {
+			throw new TypeError('Tuple is not a constructor');
+		}
+
+		const tuple = createTuple(items);
+		Object.freeze(tuple);
+		return tuple;
 	}
 
-	// const notAllowed = ['push', 'pop', 'sort', 'reverse', 'splice', 'shift', 'unshift', 'constructor'];
-	// Tuple.prototype.constructor = Tuple;
+	Tuple.prototype.forEach = function forEach(callbackFn, thisArg) {
+		Array.prototype.forEach.call(this, callbackFn, thisArg);
+	};
+
+	Tuple.prototype.join = function join(separator = ',') {
+		return Array.prototype.join.call(this, separator);
+	};
 
-	Tuple.prototype.forEach = function forEach() {
-		Array.prototype.forEach.apply(this, arguments);
+	Tuple.prototype.concat = function concat(...values) {
+		return Tuple(...this, ...values);
 	};
 
-	Tuple.prototype.join = function join() {
-		return Array.prototype.join.apply(this, arguments);
+	Tuple.prototype.slice = function slice(start, end) {
+		return Tuple.from(Array.prototype.slice.call(this, start, end));
 	};
 
-	Tuple.prototype.indexOf = function indexOf() {
-		return Array.prototype.indexOf.apply(this, arguments);
+	Tuple.prototype.indexOf = function indexOf(searchElement, fromIndex) {
+		return Array.prototype.indexOf.call(this, searchElement, fromIndex);
 	};
 
-	Tuple.prototype.lastIndexOf = function lastIndexOf() {
-		return Array.prototype.lastIndexOf.apply(this, arguments);
+	Tuple.prototype.lastIndexOf = function lastIndexOf(searchElement, fromIndex) {
+		return Array.prototype.lastIndexOf.call(this, searchElement, fromIndex);
 	};
 
-	Tuple.prototype.findIndex = function findIndex() {
-		return Array.prototype.findIndex.apply(this, arguments);
+	Tuple.prototype.findIndex = function findIndex(callbackFn, thisArg) {
+		return Array.prototype.findIndex.call(this, callbackFn, thisArg);
 	};
 
-	Tuple.prototype.find = function find() {
-		return Array.prototype.find.apply(this, arguments);
+	Tuple.prototype.find = function find(callbackFn, thisArg) {
+		return Array.prototype.find.call(this, callbackFn, thisArg);
 	};
 
-	Tuple.prototype.findLast = function findLast() {
-		return Array.prototype.findLast.apply(this, arguments);
+	Tuple.prototype.findLast = function findLast(callbackFn, thisArg) {
+		return Array.prototype.findLast.call(this, callbackFn, thisArg);
 	};
 
-	Tuple.prototype.findLastIndex = function findLastIndex() {
-		return Array.prototype.findLastIndex.apply(this, arguments);
+	Tuple.prototype.findLastIndex = function findLastIndex(callbackFn, thisArg) {
+		return Array.prototype.findLastIndex.call(this, callbackFn, thisArg);
 	};
 
-	Tuple.prototype.every = function every() {
-		return Array.prototype.every.apply(this, arguments);
+	Tuple.prototype.every = function every(callbackFn, thisArg) {
+		return Array.prototype.every.call(this, callbackFn, thisArg);
 	};
 
-	Tuple.prototype.some = function some() {
-		return Array.prototype.some.apply(this, arguments);
+	Tuple.prototype.some = function some(callbackFn, thisArg) {
+		return Array.prototype.some.call(this, callbackFn, thisArg);
 	};
 
-	Tuple.prototype.includes = function includes() {
-		return Array.prototype.includes.apply(this, arguments);
+	Tuple.prototype.includes = function includes(searchElement, fromIndex) {
+		return Array.prototype.includes.call(this, searchElement, fromIndex);
 	};
 
-	Tuple.prototype.map = function map() {
-		return Tuple.from(Array.prototype.map.apply(this, arguments));
+	Tuple.prototype.map = function map(callbackFn, thisArg) {
+		return Tuple.from(Array.prototype.map.call(this, callbackFn, thisArg));
 	};
 
-	Tuple.prototype.filter = function filter() {
-		return Tuple.from(Array.prototype.filter.apply(this, arguments));
+	Tuple.prototype.filter = function filter(callbackFn, thisArg) {
+		return Tuple.from(Array.prototype.filter.call(this, callbackFn, thisArg));
 	};
 
-	Tuple.prototype.flat = function flat() {
-		return Tuple.from(Array.prototype.flat.apply(this, arguments));
+	Tuple.prototype.flat = function flat(depth) {
+		return Tuple.from(Array.prototype.flat.call(this, depth));
 	};
 
-	Tuple.prototype.flatMap = function flatMap() {
-		return Tuple.from(Array.prototype.flatMap.apply(this, arguments));
+	Tuple.prototype.flatMap = function flatMap(callbackFn, thisArg) {
+		return Tuple.from(Array.prototype.flatMap.call(this, callbackFn, thisArg));
 	};
 
-	Tuple.prototype.at = function at() {
-		return Array.prototype.at.apply(this, arguments);
+	Tuple.prototype.at = function at(index) {
+		return Array.prototype.at.call(this, index);
 	};
 
-	Tuple.prototype.reduce = function reduce() {
-		return Tuple.from(Array.prototype.reduce.apply(this, arguments));
+	Tuple.prototype.reduce = function reduce(callbackFn, initialValue) {
+		return Tuple.from(Array.prototype.reduce.call(this, callbackFn, initialValue));
 	};
 
-	Tuple.prototype.reduceRight = function reduceRight() {
-		return Tuple.from(Array.prototype.reduceRight.apply(this, arguments));
+	Tuple.prototype.reduceRight = function reduceRight(callbackFn, initialValue) {
+		return Tuple.from(Array.prototype.reduceRight.call(this, callbackFn, initialValue));
 	};
 
-	Tuple.prototype.toSorted = function toSorted() {
-		return Tuple.from(Array.prototype.toSorted.apply(this, arguments));
+	Tuple.prototype.toSorted = function toSorted(toStringTag) {
+		return Tuple.from(Array.prototype.toSorted.call(this, toStringTag));
 	};
 
-	Tuple.prototype.toSpliced = function toSpliced() {
-		return Tuple.from(Array.prototype.toSpliced.apply(this, arguments));
+	Tuple.prototype.toSpliced = function toSpliced(start, deleteCount, ...items) {
+		return Tuple.from(Array.prototype.toSpliced.call(this, start, deleteCount, ...items));
 	};
 
 	Tuple.prototype.toReversed = function toReversed() {
-		return Tuple.from(Array.prototype.toReversed.apply(this, arguments));
+		return Tuple.from(Array.prototype.toReversed.apply(this));
+	};
+
+	Tuple.prototype.with = function(index, value) {
+		return Tuple.from(Array.prototype.with.call(this, index, value));
+	};
+
+	Tuple.prototype.toLocaleString = function toLocaleString(locales, options) {
+		return Array.prototype.toLocaleString.call(this, locales, options);
 	};
 
 	Tuple.prototype.toJSON = function toJSON() {
 		return [...this];
 	};
 
-	Tuple.prototype.keys = function keys(){
+	Tuple.prototype.keys = function keys() {
 		return Array.prototype.keys.apply(this);
 	};
 
@@ -114,8 +140,15 @@ if (! (globalThis.Tuple instanceof Function)) {
 		return Array.prototype[Symbol.iterator].apply(this);
 	};
 
-	Tuple.from = function from(items) {
-		return Tuple(...items);
+	Tuple.from = function from(items, mapFn, thisArg) {
+		const tuple = createTuple([]);
+		Array.prototype.push.apply(tuple, Array.from(items, mapFn, thisArg));
+		Object.freeze(tuple);
+		return tuple;
+	};
+
+	Tuple.of = function(...items) {
+		return Tuple.from(items);
 	};
 
 	Object.defineProperties(Tuple.prototype, {
@@ -139,7 +172,13 @@ if (! (globalThis.Tuple instanceof Function)) {
 			},
 			enumerable: true,
 			configurable: false,
-		}
+		},
+		[Symbol.toStringTag]: {
+			value: 'Tuple',
+			enumerable: true,
+			configurable: false,
+			writable: false,
+		},
 	});
 
 	globalThis.Tuple = Tuple;