poveste 0.18.1 → 0.18.2

package/dist/node/dom/env.d.ts

@@ -1,3 +1,4 @@
+import './iterator.js';
 export declare function createDomEnv(): {
     window: Window & typeof globalThis;
     destroy: () => void;

package/dist/node/dom/env.js

@@ -1,6 +1,11 @@
+/* eslint-disable perfectionist/sort-imports -- order is load order here */
+// First, and kept first: it defines `Iterator` where the runtime lacks it, and
+// jsdom extends `Iterator` while it loads (#1238).
+import './iterator.js';
 import { JSDOM, VirtualConsole, } from 'jsdom';
 import { isError } from '../util/is-error.js';
 import { populateGlobal } from './util.js';
+/* eslint-enable perfectionist/sort-imports */
 // jsdom error types — not exported by jsdom.
 const JSDOM_ERROR_CSS_PARSING = 'css-parsing';
 const JSDOM_ERROR_UNHANDLED_EXCEPTION = 'unhandled-exception';

package/dist/node/dom/iterator.d.ts

@@ -0,0 +1,2 @@
+/** Defines `globalThis.Iterator` and its helpers where the runtime has neither. */
+export declare function installIterator(): void;

package/dist/node/dom/iterator.js

@@ -0,0 +1,213 @@
+// StackBlitz's WebContainer reports Node 22.22.3 but has no global `Iterator`, and
+// jsdom 30.1 extends it when it loads, so every story failed to collect there
+// (#1238). Real Node has had it since 22.0 and never runs this.
+//
+// Vendored rather than core-js: core-js and core-js-pure both carry a postinstall,
+// and pnpm 11 and 12 fail an install outright on a dependency's unapproved build
+// script. The full ES2025 helper set rather than only the `find` jsdom calls
+// today, so the next helper jsdom reaches for is already here.
+const IteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]()));
+function callable(fn, name) {
+    if (typeof fn !== 'function') {
+        throw new TypeError(`Iterator.prototype.${name} expects a function`);
+    }
+    return fn;
+}
+function count(value, name) {
+    const n = Number(value);
+    if (Number.isNaN(n)) {
+        throw new RangeError(`Iterator.prototype.${name} expects a number`);
+    }
+    const whole = Math.trunc(n);
+    if (whole < 0) {
+        throw new RangeError(`Iterator.prototype.${name} expects a non-negative number`);
+    }
+    return whole;
+}
+// Closing after a callback threw keeps the callback's error, as the spec does.
+function closeQuietly(iterator) {
+    try {
+        iterator.return?.();
+    }
+    catch { }
+}
+function guarded(iterator, run) {
+    try {
+        return run();
+    }
+    catch (error) {
+        closeQuietly(iterator);
+        throw error;
+    }
+}
+/**
+ * A lazy helper. `step` turns each value into what to yield, and `stop` ends it
+ * before the next read. The underlying iterator is closed whenever this one ends
+ * before it does.
+ */
+function lazy(iterator, step, stop = () => false) {
+    const next = iterator.next;
+    return (function* () {
+        let exhausted = false;
+        try {
+            for (let index = 0; !stop(); index++) {
+                const result = next.call(iterator);
+                if (result.done) {
+                    exhausted = true;
+                    return;
+                }
+                yield* guarded(iterator, () => step(result.value, index));
+            }
+        }
+        finally {
+            if (!exhausted) {
+                closeQuietly(iterator);
+            }
+        }
+    })();
+}
+/** An eager helper: `visit` returns true to stop, which closes the iterator. */
+function each(iterator, visit) {
+    const next = iterator.next;
+    for (let index = 0;; index++) {
+        const result = next.call(iterator);
+        if (result.done) {
+            return;
+        }
+        if (guarded(iterator, () => visit(result.value, index))) {
+            closeQuietly(iterator);
+            return;
+        }
+    }
+}
+function flattenable(value, name) {
+    if (value === null || (typeof value !== 'object' && typeof value !== 'function')) {
+        throw new TypeError(`Iterator.${name} expects an iterator or an iterable`);
+    }
+    const method = Reflect.get(value, Symbol.iterator);
+    const inner = method === undefined ? value : method.call(value);
+    return { [Symbol.iterator]: () => inner };
+}
+const helpers = {
+    map(fn) {
+        const mapper = callable(fn, 'map');
+        return lazy(this, (value, index) => [mapper(value, index)]);
+    },
+    filter(fn) {
+        const predicate = callable(fn, 'filter');
+        return lazy(this, (value, index) => (predicate(value, index) ? [value] : []));
+    },
+    take(limit) {
+        let remaining = count(limit, 'take');
+        return lazy(this, (value) => {
+            remaining--;
+            return [value];
+        }, () => remaining === 0);
+    },
+    drop(limit) {
+        let remaining = count(limit, 'drop');
+        return lazy(this, (value) => {
+            if (remaining > 0) {
+                remaining--;
+                return [];
+            }
+            return [value];
+        });
+    },
+    flatMap(fn) {
+        const mapper = callable(fn, 'flatMap');
+        return lazy(this, (value, index) => flattenable(mapper(value, index), 'prototype.flatMap'));
+    },
+    reduce(fn, ...initial) {
+        const reducer = callable(fn, 'reduce');
+        let accumulator = initial[0];
+        let started = initial.length > 0;
+        each(this, (value, index) => {
+            if (started) {
+                accumulator = reducer(accumulator, value, index);
+            }
+            else {
+                accumulator = value;
+                started = true;
+            }
+            return false;
+        });
+        if (!started) {
+            throw new TypeError('Iterator.prototype.reduce of an empty iterator with no initial value');
+        }
+        return accumulator;
+    },
+    toArray() {
+        const out = [];
+        each(this, (value) => {
+            out.push(value);
+            return false;
+        });
+        return out;
+    },
+    forEach(fn) {
+        const visit = callable(fn, 'forEach');
+        each(this, (value, index) => {
+            visit(value, index);
+            return false;
+        });
+    },
+    some(fn) {
+        const predicate = callable(fn, 'some');
+        let found = false;
+        each(this, (value, index) => {
+            found = Boolean(predicate(value, index));
+            return found;
+        });
+        return found;
+    },
+    every(fn) {
+        const predicate = callable(fn, 'every');
+        let all = true;
+        each(this, (value, index) => {
+            all = Boolean(predicate(value, index));
+            return !all;
+        });
+        return all;
+    },
+    find(fn) {
+        const predicate = callable(fn, 'find');
+        let found;
+        each(this, (value, index) => {
+            if (predicate(value, index)) {
+                found = value;
+                return true;
+            }
+            return false;
+        });
+        return found;
+    },
+};
+/** Defines `globalThis.Iterator` and its helpers where the runtime has neither. */
+export function installIterator() {
+    if (typeof Reflect.get(globalThis, 'Iterator') !== 'undefined') {
+        return;
+    }
+    function Iterator() {
+        if (new.target === undefined || new.target === Iterator) {
+            throw new TypeError('Iterator is an abstract class and cannot be constructed directly');
+        }
+    }
+    Iterator.prototype = IteratorPrototype;
+    Object.defineProperty(IteratorPrototype, 'constructor', { value: Iterator, writable: true, configurable: true });
+    Object.defineProperty(Iterator, 'from', {
+        value(value) {
+            const iterator = (typeof value === 'string' ? value : flattenable(value, 'from'))[Symbol.iterator]();
+            return Object.prototype.isPrototypeOf.call(IteratorPrototype, iterator) ? iterator : lazy(iterator, item => [item]);
+        },
+        writable: true,
+        configurable: true,
+    });
+    for (const [name, fn] of Object.entries(helpers)) {
+        if (!(name in IteratorPrototype)) {
+            Object.defineProperty(IteratorPrototype, name, { value: fn, writable: true, configurable: true });
+        }
+    }
+    Object.defineProperty(globalThis, 'Iterator', { value: Iterator, writable: true, configurable: true });
+}
+installIterator();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "poveste",
   "type": "module",
-  "version": "0.18.1",
+  "version": "0.18.2",
   "description": "Interactive component playgrounds for Vue, Nuxt, Svelte, SvelteKit and Quasar, plus Solid (renderer only) — a drop-in fork of histoire, with Quasar support histoire does not ship.",
   "author": {
     "name": "Sorin Gitlan",
@@ -77,10 +77,10 @@
   },
   "dependencies": {
     "@11ty/gray-matter": "^3.0.0",
-    "@poveste/app": "^0.18.1",
-    "@poveste/controls": "^0.18.1",
-    "@poveste/shared": "^0.18.1",
-    "@poveste/vendors": "^0.18.1",
+    "@poveste/app": "^0.18.2",
+    "@poveste/controls": "^0.18.2",
+    "@poveste/shared": "^0.18.2",
+    "@poveste/vendors": "^0.18.2",
     "change-case": "^5.4.4",
     "chokidar": "^5.0.0",
     "defu": "^6.1.4",