wip(iterator.from): Attempting to fix Interator.from to work

Author: elimanzo

workspaces/adventure-pack/goodies/typescript/Iterator.from/index.test.ts

@@ -4,6 +4,11 @@ import "./index";
 import "../Iterator.prototype.map";
 import "../Iterator.prototype.filter";
 
+(globalThis as Record<string, unknown>).Iterator &&
+  delete (
+    (globalThis as Record<string, unknown>).Iterator as Record<string, unknown>
+  ).from;
+
 describe("Iterator.from", () => {
   it("can convert an Array to an Iterator", () => {
     const array = [-3, 1, -4, 1, -5];
@@ -69,15 +74,15 @@ describe("Iterator.from", () => {
     const object = {
       values: [-3, 1, -4, 1, -5, 9],
       index: 0,
-      next() {
+      next(): IteratorResult<number, void> {
         if (this.index < this.values.length) {
           return { value: this.values[this.index++], done: false };
         }
         return { done: true, value: undefined };
       },
     };
     const iterator = Iterator.from(object)
-      .map((x) => (x !== undefined ? x * 2 : 0))
+      .map((x) => x * 2)
       .filter((x) => x > 0);
 
     expect([...iterator]).toStrictEqual([2, 2, 18]);

workspaces/adventure-pack/goodies/typescript/Iterator.from/index.ts

@@ -13,32 +13,31 @@ declare global {
 
 (globalThis as Record<string, unknown>).Iterator ??= {};
 
-(globalThis as Record<string, unknown>).Iterator = {
-  from<T>(
+((globalThis as Record<string, unknown>).Iterator as { from: unknown }).from ??=
+  function <T>(
     object: Iterator<T> | Iterable<T> | { next(): IteratorResult<T> },
   ): IterableIterator<T> {
-    if (typeof (object as Iterable<T>)[Symbol.iterator] === "function") {
-      const iterable = object as Iterable<T>;
-      const iterator = iterable[Symbol.iterator]();
-      return iteratorPrototype.toIterable.call(iterator) as IterableIterator<T>;
+    const toIterable = iteratorPrototype.toIterable as (
+      this: Iterator<T>,
+    ) => IterableIterator<T>;
+
+    const iteratorFactory = (object as Iterable<T>)[Symbol.iterator];
+    if (typeof iteratorFactory === "function") {
+      return toIterable.call(iteratorFactory.call(object));
     }
 
-    if (Object.prototype.isPrototypeOf.call(iteratorPrototype, object)) {
-      return iteratorPrototype.toIterable.call(
-        object as Iterator<T>,
-      ) as IterableIterator<T>;
+    // eslint-disable-next-line no-prototype-builtins
+    if (iteratorPrototype.isPrototypeOf(object)) {
+      return toIterable.call(object as Iterator<T>);
     }
 
-    if (typeof (object as { next(): IteratorResult<T> }).next === "function") {
-      return (function* (): IterableIterator<T> {
-        yield* iteratorPrototype.toIterable.call(
-          object as Iterator<T>,
-        ) as Iterable<T>;
+    if (typeof (object as Record<string, unknown>).next === "function") {
+      return (function* () {
+        yield* toIterable.call(object as Iterator<T>);
       })();
     }
 
     throw new TypeError(
       "Object is not an iterator, iterable, or an object with a next method",
     );
-  },
-};
+  };