poveste 0.18.1 → 0.18.3

package/dist/node/commands/port.d.ts

@@ -7,11 +7,23 @@
  * neither the flag nor the mistake. A non-numeric value fails the same way.
  */
 export declare function resolvePort(value: unknown, command: string): number | undefined;
+type SocketOptions = Record<string, unknown>;
 /**
- * The HMR socket port for a book served on `devPort`. Derived from the dev port
- * so each concurrent dev server's socket is as distinct as its book port (#175),
- * offset clear of the usual dev-port range and wrapped so it stays a valid port
- * for an unusually high `--port`. `@nuxt/vite-builder` otherwise pins every
- * server to the framework default (24678), a constant that collides (#221).
+ * The book server's HMR socket settings: whatever the merged config asked for,
+ * minus a port or server of its own, so Vite serves the socket on the book's port
+ * and the browser dials the page's own origin. Vite takes these from `server.ws`
+ * and from the deprecated `server.hmr` alike, so both are cleared.
+ *
+ * A socket on a second port was never routed on StackBlitz, which previews each
+ * port on its own hostname, so a page opened before collection ended waited for
+ * the list on a socket that never connected, and stayed blank (#1245). It is
+ * also how `@nuxt/vite-builder`'s 24678 default made two books collide (#221).
  */
-export declare function hmrPortFor(devPort: number | undefined): number;
+export declare function socketOnBookPort(server: {
+    hmr?: unknown;
+    ws?: unknown;
+}): {
+    hmr: SocketOptions;
+    ws: SocketOptions;
+};
+export {};

package/dist/node/commands/port.js

@@ -22,14 +22,24 @@ export function resolvePort(value, command) {
     }
     return port;
 }
+function withoutOwnPort(options) {
+    if (options === null || typeof options !== 'object') {
+        return {};
+    }
+    const { port: _port, server: _server, ...rest } = options;
+    return rest;
+}
 /**
- * The HMR socket port for a book served on `devPort`. Derived from the dev port
- * so each concurrent dev server's socket is as distinct as its book port (#175),
- * offset clear of the usual dev-port range and wrapped so it stays a valid port
- * for an unusually high `--port`. `@nuxt/vite-builder` otherwise pins every
- * server to the framework default (24678), a constant that collides (#221).
+ * The book server's HMR socket settings: whatever the merged config asked for,
+ * minus a port or server of its own, so Vite serves the socket on the book's port
+ * and the browser dials the page's own origin. Vite takes these from `server.ws`
+ * and from the deprecated `server.hmr` alike, so both are cleared.
+ *
+ * A socket on a second port was never routed on StackBlitz, which previews each
+ * port on its own hostname, so a page opened before collection ended waited for
+ * the list on a socket that never connected, and stayed blank (#1245). It is
+ * also how `@nuxt/vite-builder`'s 24678 default made two books collide (#221).
  */
-export function hmrPortFor(devPort) {
-    const base = devPort ?? 6006;
-    return base < 45536 ? base + 20000 : base - 20000;
+export function socketOnBookPort(server) {
+    return { hmr: withoutOwnPort(server.hmr), ws: withoutOwnPort(server.ws) };
 }

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/dist/node/server.js

@@ -2,7 +2,7 @@ import { performance } from 'node:perf_hooks';
 import pc from 'picocolors';
 import { createServer as createViteServer, mergeConfig as mergeViteConfig } from 'vite';
 import { useCollectStories } from './collect/index.js';
-import { hmrPortFor } from './commands/port.js';
+import { socketOnBookPort } from './commands/port.js';
 import { useModuleLoader } from './load.js';
 import { createMarkdownFilesWatcher, onMarkdownFileChange, onMarkdownListChange } from './markdown.js';
 import { DevEventPluginApi, DevPluginApi } from './plugin.js';
@@ -42,14 +42,19 @@ async function startServer(ctx, options, onOpen, close) {
             serverConfig.hmr = false;
         }
         else {
-            // `@nuxt/vite-builder` pins the HMR socket to the constant 24678 on every
-            // server it configures, so two poveste dev servers on different `--port`s
-            // collide on it and the second silently loses HMR (#221). It only does
-            // this when `server.hmr` carries no port of its own (it fills the gap with
-            // `defu`), so pin the socket to a port derived from this book's `--port`,
-            // before the config is resolved: each dev server then owns a distinct one
-            // (#175).
-            serverConfig.hmr = { port: hmrPortFor(options.port ?? serverConfig.port) };
+            // On the book's own port, never a second one: StackBlitz does not route
+            // it, and `@nuxt/vite-builder`'s default collides between books (#1245,
+            // #221). Post-ordered, because that default is filled in by Nuxt's own
+            // `config` hook.
+            viteConfig.plugins = [...viteConfig.plugins ?? [], {
+                    name: 'poveste:socket-on-book-port',
+                    config: {
+                        order: 'post',
+                        handler(config) {
+                            config.server = { ...config.server, ...socketOnBookPort(config.server ?? {}) };
+                        },
+                    },
+                }];
             if (options.open) {
                 serverConfig.open = true;
             }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "poveste",
   "type": "module",
-  "version": "0.18.1",
+  "version": "0.18.3",
   "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.3",
+    "@poveste/controls": "^0.18.3",
+    "@poveste/shared": "^0.18.3",
+    "@poveste/vendors": "^0.18.3",
     "change-case": "^5.4.4",
     "chokidar": "^5.0.0",
     "defu": "^6.1.4",