chore(pr): Applying 1st round of PR feedback

Author: elimanzo

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

@@ -47,12 +47,12 @@ describe("Iterator.from", () => {
     expect([...iterator]).toStrictEqual([...string]);
   });
 
-  it("can convert an Iterator to an Iterator", () => {
+  it("can convert an Iterator to an IterableIterator without altering the original iterator", () => {
     const array = [1, 2, 3];
-    const iterator = Iterator.from(array.values());
-    const iterator2 = Iterator.from(iterator);
+    const iterator = array.values();
+    const convertedIterator = Iterator.from(iterator);
 
-    expect([...iterator2]).toStrictEqual(array);
+    expect(iterator === convertedIterator).toBe(true);
   });
 
   it("can convert an IterableIterator to an Iterator", () => {
@@ -79,7 +79,7 @@ describe("Iterator.from", () => {
     expect([...iterator]).toStrictEqual([1, 2, 3]);
   });
 
-  it("throws an error if the object is not an IterableIterator", () => {
+  it("throws an error if the object is not an Iterator, Iterable, or an object with a next method", () => {
     const object = {};
     // @ts-expect-error Invalid argument
     expect(() => Iterator.from(object)).toThrow(TypeError);

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

@@ -1,43 +1,54 @@
 import "../Iterator.prototype.toIterable";
 
 declare global {
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  class Iterator<T> {
-    static from<TElem>(
-      object:
-        | Iterator<TElem>
-        | Iterable<TElem>
-        | { next(): IteratorResult<TElem> },
-    ): IterableIterator<TElem>;
+  interface IteratorConstructor {
+    from<T>(
+      object: Iterator<T> | Iterable<T> | { next(): IteratorResult<T> },
+    ): IterableIterator<T>;
   }
+
+  const Iterator: IteratorConstructor;
 }
 
 (globalThis as Record<string, unknown>).Iterator ??= {};
 
-(
-  (globalThis as Record<string, unknown>).Iterator as Record<string, unknown>
-).from ??= function <T>(
-  object: Iterator<T> | Iterable<T> | { next(): IteratorResult<T> },
-): IterableIterator<T> {
-  if (typeof (object as Iterable<T>)[Symbol.iterator] === "function") {
-    return (object as Iterable<T>)[Symbol.iterator]() as IterableIterator<T>;
-  }
+(globalThis as Record<string, unknown>).Iterator = {
+  from<T>(
+    object: Iterator<T> | Iterable<T> | { next(): IteratorResult<T> },
+  ): IterableIterator<T> {
+    if (typeof (object as Iterable<T>)[Symbol.iterator] === "function") {
+      const iterator = (object as Iterable<T>)[Symbol.iterator]();
+      if (typeof iterator === "object" && Symbol.iterator in iterator) {
+        return iterator as IterableIterator<T>;
+      } else {
+        return {
+          ...iterator,
+          [Symbol.iterator]() {
+            return this;
+          },
+        } as IterableIterator<T>;
+      }
+    }
 
-  if (typeof (object as Iterator<T>).toIterable === "function") {
-    return (object as Iterator<T>).toIterable();
-  }
+    if (typeof (object as Iterator<T>).toIterable === "function") {
+      return (object as Iterator<T>).toIterable();
+    }
 
-  if (typeof (object as { next(): IteratorResult<T> }).next === "function") {
-    return (function* () {
-      let result: IteratorResult<T>;
-      do {
-        result = (object as { next(): IteratorResult<T> }).next();
-        if (!result.done) {
+    if (typeof (object as { next(): IteratorResult<T> }).next === "function") {
+      return (function* () {
+        let result: IteratorResult<T>;
+        while (true) {
+          result = (object as { next(): IteratorResult<T> }).next();
+          if (result.done) {
+            break;
+          }
           yield result.value;
         }
-      } while (!result.done);
-    })();
-  }
+      })();
+    }
 
-  throw new TypeError("Object is not an Iterator or Iterable");
+    throw new TypeError(
+      "Object is not an iterator, iterable, or an object with a next method",
+    );
+  },
 };