poveste 0.8.0 → 0.8.1

package/dist/node/build.js

@@ -85,10 +85,14 @@ export async function build(ctx) {
         build: {
             lib: false,
             rollupOptions: {
-                input: [
-                    join(APP_PATH, 'bundle-main.js'),
-                    join(APP_PATH, 'bundle-sandbox.js'),
-                ],
+                // Named, not an array. With an array the bundler derives `[name]` from the
+                // path, and `APP_PATH` is absolute — so any framework whose `entryFileNames`
+                // refuses a path-shaped `[name]` fails the build outright (#369, and
+                // histoire-dev/histoire#802 before it). The keys make `[name]` the key.
+                input: {
+                    'bundle-main': join(APP_PATH, 'bundle-main.js'),
+                    'bundle-sandbox': join(APP_PATH, 'bundle-sandbox.js'),
+                },
                 plugins: [
                     {
                         name: 'poveste-build-rollup-options-override',
@@ -164,6 +168,15 @@ export async function build(ctx) {
                     }
                 },
             };
+            // A framework that declares Vite environments gives each one its own
+            // `build.outDir`, and that wins over the top-level value for the environment's
+            // output — so the book was written to the framework's directory (Vike: `dist/client`)
+            // while poveste kept looking in `outDir` (#369). Only the client environment
+            // builds the book. Where no framework declared environments there is nothing to
+            // override, and where one did this puts the book back where poveste reads it.
+            if (config.environments?.client?.build) {
+                config.environments.client.build.outDir = ctx.config.outDir;
+            }
             // Force vite build options
             Object.assign(config.build, {
                 outDir: ctx.config.outDir,

package/dist/node/collect/define-globals.d.ts

@@ -0,0 +1 @@
+export declare function globalsFromDefine(define: Record<string, unknown> | undefined): Record<string, unknown>;

package/dist/node/collect/define-globals.js

@@ -0,0 +1,42 @@
+// Story collection runs in a Node worker. Externalised dependencies are loaded by
+// native Node ESM, so Vite never applies `define` to them — and a bare compile-time
+// feature flag is just an undefined identifier there. vue-i18n reading
+// `__VUE_PROD_DEVTOOLS__` was the reported case (#284); anything with build-time
+// flags fails the same way.
+//
+// The fix is to give the collection environment the same values a real build would
+// substitute, taken from Vite's own resolved `define` rather than a list of library
+// names this package would have to keep current.
+// Only `__FLAG__`-shaped keys are seeded. Every flag this exists for follows that
+// convention — `__VUE_OPTIONS_API__`, `__VUE_PROD_DEVTOOLS__`, `__VUE_I18N_LEGACY_API__`,
+// `__INTLIFY_PROD_DEVTOOLS__` — and narrow is the right failure here. A browser-targeted
+// config shimming a Node global (`define: { process: '{"env":{}}' }` is a real shape)
+// would otherwise replace the collection worker's own `process`, surfacing far from the
+// config that caused it. Refusing to evaluate arbitrary expressions while letting
+// arbitrary identifiers overwrite the runtime would be a guard in name only.
+// `process.env.NODE_ENV` and friends fail the same test, being member expressions.
+const FEATURE_FLAG = /^__[A-Z0-9_]+__$/;
+// Vite `define` values are JS expression *source*. A plugin-injected flag arrives
+// already parsed (`false`), while a user's `define: { X: 'false' }` arrives as the
+// string `"false"` — and seeding that string would make the flag *truthy*, silently
+// inverting it. So strings are parsed as literals, and anything that is not a literal
+// is skipped: evaluating arbitrary expressions here is not something this should do.
+export function globalsFromDefine(define) {
+    const globals = {};
+    for (const [key, value] of Object.entries(define ?? {})) {
+        if (!FEATURE_FLAG.test(key)) {
+            continue;
+        }
+        if (typeof value !== 'string') {
+            globals[key] = value;
+            continue;
+        }
+        try {
+            globals[key] = JSON.parse(value);
+        }
+        catch {
+            // Not a literal — leave it undefined rather than guess at it.
+        }
+    }
+    return globals;
+}

package/dist/node/collect/index.js

@@ -8,6 +8,7 @@ import { ViteNodeServer } from 'vite-node/server';
 import { TEMP_PATH } from '../alias.js';
 import { createPath } from '../tree.js';
 import { slash } from '../util/fs.js';
+import { globalsFromDefine } from './define-globals.js';
 export function useCollectStories(options, ctx) {
     const { server, mainServer } = options;
     const node = new ViteNodeServer(server, {
@@ -34,6 +35,8 @@ export function useCollectStories(options, ctx) {
         },
         transformMode: ctx.config.viteNodeTransformMode,
     });
+    // Same values a real build substitutes, so externalised deps see their flags.
+    const defineGlobals = globalsFromDefine(server.config.define);
     const maxThreads = ctx.config.collectMaxThreads ?? cpus().length;
     const threadsCount = ctx.mode === 'dev'
         ? Math.max(Math.min(maxThreads, Math.floor(cpus().length / 2)), 1)
@@ -83,6 +86,7 @@ export function useCollectStories(options, ctx) {
                 base: server.config.base,
                 storyFile,
                 port: workerPort,
+                defineGlobals,
             };
             const { storyData } = await threadPool.run(payload, {
                 transferList: [

package/dist/node/collect/worker.d.ts

@@ -5,6 +5,7 @@ export interface Payload {
     base: string;
     port: MessagePort;
     storyFile: ServerStoryFile;
+    defineGlobals?: Record<string, unknown>;
 }
 export interface ReturnData {
     storyData: ServerStory[];

package/dist/node/collect/worker.js

@@ -22,6 +22,11 @@ parentPort.on('message', (message) => {
 export default async (payload) => {
     const startTime = performance.now();
     process.env.HST_COLLECT = 'true';
+    // Before any module runs: an externalised dep reads these at import time.
+    for (const [key, value] of Object.entries(payload.defineGlobals ?? {})) {
+        ;
+        globalThis[key] = value;
+    }
     _rpc = createBirpc({}, {
         post: data => payload.port.postMessage(data),
         on: data => payload.port.on('message', data),

package/dist/node/optimize-entries.d.ts

@@ -0,0 +1,3 @@
+import type { PovesteConfig } from '@poveste/shared';
+export declare function optimizeEntries(config: Pick<PovesteConfig, 'storyMatch' | 'storyIgnored' | 'setupFile'>, root: string, isServer: boolean): string[];
+export declare function setupFileEntry(setupFile: PovesteConfig['setupFile'], isServer: boolean): string | undefined;

package/dist/node/optimize-entries.js

@@ -0,0 +1,48 @@
+import { globbySync } from 'globby';
+import { resolve } from 'pathe';
+// Vite pre-bundles whatever its dependency scanner reaches by crawling
+// `optimizeDeps.entries`. Two things in a book route around that scan:
+//
+//   - stories are loaded dynamically, never statically imported from the app entry
+//   - the setup file is reached through `virtual:$poveste-setup`, an id the scanner
+//     cannot resolve
+//
+// So a dependency used only in a story or a setup file is discovered on first
+// navigation instead, and Vite answers with `optimized dependencies changed.
+// reloading` — a full reload that drops the preview's scroll and state (#282).
+//
+// The stories are resolved here rather than handed over as patterns, because
+// `storyIgnored` cannot be expressed as entry patterns. Vite globs the whole entries
+// array together, so a `!**/dist/**` negation would also match `APP_PATH`, which *is*
+// `<poveste-app>/dist` — silently dropping the app's own scan entries. Resolving the
+// files gives `storyIgnored` its exact meaning and cannot touch anything else.
+export function optimizeEntries(config, root, isServer) {
+    // Same call the collector makes, so the scanner sees exactly the story set the
+    // book will load — no stale `dist/` copies the book itself excludes.
+    const stories = globbySync(config.storyMatch, {
+        cwd: root,
+        ignore: config.storyIgnored,
+        absolute: true,
+    });
+    const setup = setupFileEntry(config.setupFile, isServer);
+    return setup ? [...stories, resolve(root, setup)] : stories;
+}
+// Mirrors how `virtual/vite-plugin.ts` picks the file. These are documented
+// root-relative and written with a leading slash (`/src/setup.ts`), which
+// `resolve` would read as absolute.
+export function setupFileEntry(setupFile, isServer) {
+    if (!setupFile) {
+        return undefined;
+    }
+    let file;
+    if (typeof setupFile === 'string') {
+        file = setupFile;
+    }
+    else if (isServer && 'server' in setupFile) {
+        file = setupFile.server;
+    }
+    else if (!isServer && 'browser' in setupFile) {
+        file = setupFile.browser;
+    }
+    return file ? file.replace(/^\/+/, '') : undefined;
+}

package/dist/node/vite.js

@@ -5,6 +5,7 @@ import { dirname, join, relative } from 'pathe';
 import { loadConfigFromFile as loadViteConfigFromFile, mergeConfig as mergeViteConfig, searchForWorkspaceRoot, } from 'vite';
 import { APP_PATH, TEMP_PATH } from './alias.js';
 import { createMarkdownPlugins } from './markdown.js';
+import { optimizeEntries } from './optimize-entries.js';
 import { notifyStoryChange } from './stories.js';
 import { chromeCssScopePlugin, globalStylesPlugin, userCssScopePlugin, } from './style-isolation/index.js';
 import { applyHeadTransform } from './util/head.js';
@@ -124,6 +125,9 @@ export async function getViteConfigWithPlugins(isServer, ctx) {
                     entries: [
                         `${APP_PATH}/bundle-main.js`,
                         `${APP_PATH}/bundle-sandbox.js`,
+                        // Without these the scanner never sees a story or the setup file, and
+                        // their deps cost a full reload when they turn up later (#282).
+                        ...optimizeEntries(ctx.config, ctx.root, isServer),
                     ],
                     include: optimizeDeps([
                         'shiki',

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "poveste",
   "type": "module",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "description": "Interactive component playgrounds for Vue, Svelte and Nuxt — a maintained, drop-in successor to histoire",
   "author": {
     "name": "Sorin Gitlan"
@@ -98,10 +98,10 @@
     "sirv": "^3.0.0",
     "unhead": "^3.1.0",
     "vite-node": "^6.0.0",
-    "@poveste/controls": "^0.8.0",
-    "@poveste/app": "^0.8.0",
-    "@poveste/shared": "^0.8.0",
-    "@poveste/vendors": "^0.8.0"
+    "@poveste/app": "^0.8.1",
+    "@poveste/controls": "^0.8.1",
+    "@poveste/shared": "^0.8.1",
+    "@poveste/vendors": "^0.8.1"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",