@poveste/plugin-react 0.0.1 → 0.19.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2022 Guillaume Chau (original "histoire" project)
+Copyright (c) 2026 Sorin Gitlan (poveste fork)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,7 @@
 # @poveste/plugin-react
 
-Placeholder that reserves the name for npm Trusted Publishing. The first real release is 0.19.0. See https://poveste.dev/guide/react/getting-started
+[React](https://react.dev) support for [Poveste](https://poveste.dev): write stories as `.story.tsx` files and browse them in a Poveste book.
+
+Requires Node `>=22.22.2`, `react@^19.0.0` and `react-dom@^19.0.0`, with a JSX transform such as `@vitejs/plugin-react` in your Vite config. See the [React guide](https://poveste.dev/guide/react/getting-started).
+
+This first version renders stories and variants. The source panel shows the story file. The controls panel is not wired to React: a variant with `initState` gets the generic state editor, and one without says why there is nothing there.

package/client.d.ts

@@ -0,0 +1,2 @@
+// https://github.com/microsoft/TypeScript/issues/33079
+export * from './dist/client/index'

package/collect.d.ts

@@ -0,0 +1,2 @@
+// https://github.com/microsoft/TypeScript/issues/33079
+export * from './dist/collect/index'

package/dist/client/MountStory.d.ts

@@ -0,0 +1,33 @@
+import type { Story } from '@poveste/shared';
+import type { PropType as _PropType } from '@poveste/vendors/vue';
+declare const _default: import("poveste-vue").DefineComponent<import("poveste-vue").ExtractPropTypes<{
+    story: {
+        type: _PropType<Story>;
+        required: true;
+    };
+    syncState: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    targetVariantId: {
+        type: StringConstructor;
+        default: null;
+    };
+}>, void, {}, {}, {}, import("poveste-vue").ComponentOptionsMixin, import("poveste-vue").ComponentOptionsMixin, {}, string, import("poveste-vue").PublicProps, Readonly<import("poveste-vue").ExtractPropTypes<{
+    story: {
+        type: _PropType<Story>;
+        required: true;
+    };
+    syncState: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    targetVariantId: {
+        type: StringConstructor;
+        default: null;
+    };
+}>> & Readonly<{}>, {
+    syncState: boolean;
+    targetVariantId: string;
+}, {}, {}, {}, string, import("poveste-vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/client/MountStory.js

@@ -0,0 +1,58 @@
+import { applyState, clone, reportStoryError } from '@poveste/shared';
+import { defineComponent as _defineComponent } from '@poveste/vendors/vue';
+import { variantOptions } from '../types.js';
+import { NO_CONTROLS } from './no-controls.js';
+export default _defineComponent({
+    name: 'MountStory',
+    props: {
+        story: {
+            type: Object,
+            required: true,
+        },
+        // False in a sandbox realm, which does not own the state (#964): it receives
+        // the host's. Applying `initState` there as well would race that copy.
+        syncState: {
+            type: Boolean,
+            default: true,
+        },
+        // Set by a sandbox; accepted so it is not left as a stray attribute on a
+        // component that renders nothing (#197).
+        targetVariantId: {
+            type: String,
+            default: null,
+        },
+    },
+    setup(props) {
+        const options = props.story.file?.component;
+        const rawVariants = variantOptions(options);
+        void Promise.all(props.story.variants.map(async (variant, index) => {
+            const rawVariant = rawVariants[index];
+            const initState = rawVariant?.initState ?? options.initState;
+            if (initState && props.syncState) {
+                try {
+                    applyState(variant.state, clone(await initState()));
+                }
+                catch (error) {
+                    // Reported rather than left to reject: an unhandled rejection here
+                    // never marks the variant ready, so the preview stays blank and says
+                    // nothing. The variant still renders, from the state it has.
+                    reportStoryError(error, { storyId: props.story.id, variantId: variant.id });
+                    console.error(error);
+                }
+            }
+            Object.assign(variant, {
+                // A variant with state gets the panel's state editor; one without gets
+                // the explanation, which is a custom controls slot to the panel.
+                slots: () => ({ default: rawVariant?.render, controls: initState ? undefined : NO_CONTROLS }),
+                source: rawVariant?.source ?? options.source,
+                responsiveDisabled: rawVariant?.responsiveDisabled ?? options.responsiveDisabled,
+                autoPropsDisabled: true,
+                setupApp: rawVariant?.setupApp ?? options.setupApp,
+                configReady: true,
+            });
+        }));
+    },
+    render() {
+        return null;
+    },
+});

package/dist/client/RenderStory.d.ts

@@ -0,0 +1,39 @@
+import type { Story, Variant } from '@poveste/shared';
+import type { PropType as _PropType } from '@poveste/vendors/vue';
+declare const _default: import("poveste-vue").DefineComponent<import("poveste-vue").ExtractPropTypes<{
+    variant: {
+        type: _PropType<Variant>;
+        required: true;
+    };
+    story: {
+        type: _PropType<Story>;
+        required: true;
+    };
+    slotName: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, {
+    el: import("poveste-vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+    explainsControls: () => boolean;
+}, {}, {}, {}, import("poveste-vue").ComponentOptionsMixin, import("poveste-vue").ComponentOptionsMixin, {
+    ready: () => true;
+}, string, import("poveste-vue").PublicProps, Readonly<import("poveste-vue").ExtractPropTypes<{
+    variant: {
+        type: _PropType<Variant>;
+        required: true;
+    };
+    story: {
+        type: _PropType<Story>;
+        required: true;
+    };
+    slotName: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{
+    onReady?: () => any;
+}>, {
+    slotName: string;
+}, {}, {}, {}, string, import("poveste-vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/client/RenderStory.js

@@ -0,0 +1,175 @@
+import { getSetupHook as _getSetupHook, clone, isEquivalent, reportStoryError } from '@poveste/shared';
+import { defineComponent as _defineComponent, h as _h, onBeforeUnmount as _onBeforeUnmount, onMounted as _onMounted, ref as _ref, toRaw as _toRaw, watch as _watch, } from '@poveste/vendors/vue';
+import { createElement, useSyncExternalStore } from 'react';
+import { flushSync } from 'react-dom';
+import { createRoot } from 'react-dom/client';
+// @ts-expect-error virtual module id
+import * as generatedSetup from 'virtual:$poveste-generated-global-setup';
+// @ts-expect-error virtual module id
+import * as setup from 'virtual:$poveste-setup';
+import { REACT_SETUP_HOOK_NAMES } from '../index.js';
+import { NO_CONTROLS, NO_CONTROLS_MESSAGE } from './no-controls.js';
+export default _defineComponent({
+    name: 'RenderStory',
+    props: {
+        variant: {
+            type: Object,
+            required: true,
+        },
+        story: {
+            type: Object,
+            required: true,
+        },
+        slotName: {
+            type: String,
+            default: 'default',
+        },
+    },
+    emits: {
+        ready: () => true,
+    },
+    setup(props, { emit }) {
+        const el = _ref();
+        const slot = () => Reflect.get(props.variant.slots?.() ?? {}, props.slotName);
+        const explainsControls = () => slot() === NO_CONTROLS;
+        let root;
+        let stopSync;
+        let mounting = false;
+        async function mount() {
+            if (!props.variant.configReady) {
+                return;
+            }
+            // Checked before the element: the explanation renders no `el`, and the
+            // panel waits on this `ready` before it shows its toolbar.
+            if (explainsControls()) {
+                emit('ready');
+                return;
+            }
+            if (mounting || root || !el.value) {
+                return;
+            }
+            const renderVariant = slot();
+            if (!renderVariant) {
+                return;
+            }
+            mounting = true;
+            // Hooks run before mount, as in `@poveste/plugin-vue`, so a wrapper they
+            // add is in place for the first render rather than arriving after it.
+            const wrappers = [];
+            const setupApi = {
+                story: props.story,
+                variant: props.variant,
+                addWrapper: (wrapper) => {
+                    wrappers.unshift(wrapper);
+                },
+            };
+            const occupant = { storyId: props.story.id, variantId: props.variant.id };
+            try {
+                await _getSetupHook(generatedSetup, REACT_SETUP_HOOK_NAMES)?.(setupApi);
+                await _getSetupHook(setup, REACT_SETUP_HOOK_NAMES)?.(setupApi);
+                await props.variant.setupApp?.(setupApi);
+                // A hook that awaited can outlive this component, whose element is gone
+                // by then; rendering now would leave a React root and a watcher that no
+                // unmount will ever reach.
+                if (!el.value) {
+                    return;
+                }
+                // React reads state as a snapshot, so the variant's reactive state is
+                // copied out and replaced whole on each change: a new object is what
+                // tells `useSyncExternalStore` to render again.
+                const store = snapshotStore(clone(_toRaw(props.variant.state) ?? {}));
+                const setState = (next) => {
+                    const current = store.get();
+                    const merged = { ...current, ...(typeof next === 'function' ? next(current) : next) };
+                    store.set(merged);
+                    writeBack(props.variant.state, merged);
+                };
+                stopSync = _watch(() => props.variant.state, (value) => {
+                    const incoming = clone(_toRaw(value));
+                    if (!isEquivalent(incoming, store.get())) {
+                        store.set(incoming);
+                    }
+                }, { deep: true });
+                function Variant() {
+                    const state = useSyncExternalStore(store.subscribe, store.get);
+                    return renderVariant({ state, setState });
+                }
+                let node = createElement(Variant);
+                for (const wrapper of wrappers) {
+                    node = createElement(wrapper, { story: props.story, variant: props.variant, children: node });
+                }
+                root = createRoot(el.value, {
+                    // A render that throws is reported here rather than to the window,
+                    // where nothing would tie it to the variant that threw.
+                    onUncaughtError: (error) => {
+                        reportStoryError(error, occupant);
+                        console.error(error);
+                    },
+                });
+                // Synchronously, so `ready` means the story is in the DOM rather than
+                // scheduled to be.
+                flushSync(() => root.render(node));
+            }
+            catch (error) {
+                // Whatever got as far as existing goes with the failure, so a later
+                // attempt starts clean rather than beside a watcher nothing can stop.
+                unmount();
+                reportStoryError(error, occupant);
+                console.error(error);
+            }
+            finally {
+                mounting = false;
+            }
+            emit('ready');
+        }
+        function unmount() {
+            stopSync?.();
+            stopSync = undefined;
+            root?.unmount();
+            root = undefined;
+        }
+        _onMounted(mount);
+        _watch(() => props.variant.configReady, mount);
+        _onBeforeUnmount(unmount);
+        return { el, explainsControls };
+    },
+    render() {
+        if (this.explainsControls()) {
+            return _h('p', { class: 'poveste-react-no-controls', style: 'padding: 12px; opacity: 0.7; font-size: 12px' }, NO_CONTROLS_MESSAGE);
+        }
+        return _h('div', { ref: 'el' });
+    },
+});
+function snapshotStore(initial) {
+    let snapshot = initial;
+    const listeners = new Set();
+    return {
+        get: () => snapshot,
+        set: (next) => {
+            snapshot = next;
+            for (const listener of listeners)
+                listener();
+        },
+        subscribe: (listener) => {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+    };
+}
+/**
+ * Carries the snapshot back to the variant's state one key at a time: only what
+ * changed is cloned, and a key the snapshot no longer has is removed rather than
+ * left behind. The `_h` keys are the app's own and are never the story's to drop.
+ */
+function writeBack(target, snapshot) {
+    for (const key of Object.keys(target)) {
+        if (!key.startsWith('_h') && !Object.hasOwn(snapshot, key)) {
+            delete target[key];
+        }
+    }
+    for (const key of Object.keys(snapshot)) {
+        if (!Object.hasOwn(target, key) || !isEquivalent(target[key], snapshot[key])) {
+            target[key] = clone(snapshot[key]);
+        }
+    }
+}

package/dist/client/contract.d.ts

@@ -0,0 +1,6 @@
+import type { ClientSupportPlugin } from '@poveste/shared';
+import type { Component } from '@poveste/vendors/vue';
+import type * as client from './index.js';
+type Satisfies<T extends ClientSupportPlugin<Component>> = T;
+export type ClientContract = Satisfies<typeof client>;
+export {};

package/dist/client/contract.js

@@ -0,0 +1 @@
+export {};

package/dist/client/index.d.ts

@@ -0,0 +1,9 @@
+export { default as MountStory } from './MountStory.js';
+export { default as RenderStory } from './RenderStory.js';
+/**
+ * Exported though it generates nothing: the source panel early-returns when a
+ * plugin has none, and would then skip its switch to the story file (#61, #1115).
+ * `plugin-vue`'s codegen turns a render tree back into source; React elements
+ * carry no source to recover, so the panel shows the story file instead.
+ */
+export declare function generateSourceCode(): undefined;

package/dist/client/index.js

@@ -0,0 +1,11 @@
+export { default as MountStory } from './MountStory.js';
+export { default as RenderStory } from './RenderStory.js';
+/**
+ * Exported though it generates nothing: the source panel early-returns when a
+ * plugin has none, and would then skip its switch to the story file (#61, #1115).
+ * `plugin-vue`'s codegen turns a render tree back into source; React elements
+ * carry no source to recover, so the panel shows the story file instead.
+ */
+export function generateSourceCode() {
+    // noop
+}

package/dist/client/no-controls.d.ts

@@ -0,0 +1,3 @@
+/** Marks a variant's controls slot as the explanation, not a render function. */
+export declare const NO_CONTROLS: unique symbol;
+export declare const NO_CONTROLS_MESSAGE = "React stories have no controls yet. Give the variant an initState to edit its state here.";

package/dist/client/no-controls.js

@@ -0,0 +1,3 @@
+/** Marks a variant's controls slot as the explanation, not a render function. */
+export const NO_CONTROLS = Symbol('poveste:react-no-controls');
+export const NO_CONTROLS_MESSAGE = 'React stories have no controls yet. Give the variant an initState to edit its state here.';

package/dist/collect/index.d.ts

@@ -0,0 +1,2 @@
+import type { ServerRunPayload } from '@poveste/shared';
+export declare function run({ file, storyData }: ServerRunPayload): Promise<void>;

package/dist/collect/index.js

@@ -0,0 +1,23 @@
+import { variantOptions } from '../types.js';
+// Collection reads the story object and nothing else: no `render` is called, so
+// no Solid component runs while the book is being indexed.
+export async function run({ file, storyData }) {
+    const { default: options } = await import(/* @vite-ignore */ file.moduleId);
+    const story = {
+        id: options.id ?? file.id,
+        title: options.title ?? file.fileName,
+        group: options.group,
+        layout: options.layout ?? { type: 'single', iframe: true },
+        icon: options.icon,
+        iconColor: options.iconColor,
+        docsOnly: options.docsOnly ?? false,
+        variants: [],
+    };
+    story.variants = variantOptions(options).map((variant, index) => ({
+        id: variant.id ?? `${story.id}-${index}`,
+        title: variant.title ?? 'untitled',
+        icon: variant.icon ?? options.icon,
+        iconColor: variant.iconColor ?? options.iconColor,
+    }));
+    storyData.push(story);
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import type { Plugin } from '@poveste/shared';
+export declare const REACT_SETUP_HOOK_NAMES: string[];
+export declare function HstReact(): Plugin;
+export * from './types.js';

package/dist/index.js

@@ -0,0 +1,71 @@
+// No Node-only import here, on purpose: a story file imports `defineStory` from
+// this entry, so it is bundled for the browser as well as loaded by the config.
+export const REACT_SETUP_HOOK_NAMES = ['setupReact'];
+export function HstReact() {
+    return {
+        name: '@poveste/plugin-react',
+        defaultConfig() {
+            return {
+                // Added to core's defaults rather than replacing them (#1124), so a book
+                // with React stories needs no `storyMatch` of its own.
+                storyMatch: ['**/*.story.tsx', '**/*.story.jsx'],
+                supportMatch: [
+                    {
+                        id: 'react',
+                        patterns: ['**/*.story.tsx', '**/*.story.jsx'],
+                        pluginIds: ['react'],
+                    },
+                ],
+                vite: {
+                    plugins: [
+                        reloadOnStoryEdit(),
+                    ],
+                    // The story's JSX and this plugin's renderer must share one React: a
+                    // hook called through a second copy throws "Invalid hook call", the
+                    // same split as two Vue runtimes (#1060).
+                    resolve: {
+                        dedupe: ['react', 'react-dom'],
+                    },
+                    // React ships CommonJS, so Vite pre-bundles it, and the renderer's
+                    // imports are found only once a story is opened. Found in two passes,
+                    // the second re-chunks `react-dom` while the server still hands out the
+                    // first pass's copy, and `react-dom/client` fails to import from it on
+                    // every load until the cache is cleared. Named here, all of them are
+                    // bundled in the first pass.
+                    optimizeDeps: {
+                        include: ['react', 'react/jsx-runtime', 'react/jsx-dev-runtime', 'react-dom', 'react-dom/client'],
+                    },
+                },
+            };
+        },
+        supportPlugin: {
+            id: 'react',
+            moduleName: '@poveste/plugin-react',
+            setupFn: REACT_SETUP_HOOK_NAMES,
+            importStoryComponent: (file, index) => `import Comp${index} from ${JSON.stringify(file.moduleId)}`,
+        },
+    };
+}
+export * from './types.js';
+/**
+ * Reloads the book when a React story file is edited in dev.
+ *
+ * A story file is data, so there is no component for Fast Refresh to patch in
+ * place, and the sandbox keeps the story it mapped on mount rather than taking
+ * the updated module: the edit was collected and then never shown. A reload
+ * shows it, at the cost of whatever was set in the panel. A component the story
+ * imports is not a story file and still refreshes in place.
+ */
+function reloadOnStoryEdit() {
+    return {
+        name: 'poveste:react-story-reload',
+        apply: 'serve',
+        handleHotUpdate({ file, server }) {
+            if (!/\.story\.[jt]sx$/.test(file)) {
+                return undefined;
+            }
+            server.ws.send({ type: 'full-reload' });
+            return [];
+        },
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,44 @@
+import type { Awaitable, Story, StoryProps, Variant, VariantProps } from '@poveste/shared';
+import type { ComponentType, ReactNode } from 'react';
+export interface ReactRenderApi<S extends object> {
+    /** This render's snapshot. Never mutate it; call `setState`. */
+    state: S;
+    /**
+     * Merges into the state, as a class component's `setState` does: pass the
+     * keys that change, or a function of the current state. Changes also reach
+     * the controls panel and the host.
+     */
+    setState: (next: Partial<S> | ((state: S) => Partial<S>)) => void;
+}
+export interface ReactStorySetupApi {
+    story: Story;
+    variant: Variant;
+    /**
+     * Wraps every story this hook runs for. The first added is the outermost,
+     * as in `@poveste/plugin-vue`.
+     */
+    addWrapper: (wrapper: ReactWrapper) => void;
+}
+export type ReactWrapper = ComponentType<{
+    story: Story;
+    variant: Variant;
+    children: ReactNode;
+}>;
+export type ReactStorySetupHandler = (api: ReactStorySetupApi) => Awaitable<void>;
+export interface VariantOptions<S extends object = Record<string, any>> extends Omit<VariantProps, 'setupApp'> {
+    /** A component body: called on every render, so hooks are allowed. */
+    render: (api: ReactRenderApi<S>) => ReactNode;
+    initState?: () => Awaitable<S>;
+    setupApp?: ReactStorySetupHandler;
+}
+export interface StoryOptions<S extends object = Record<string, any>> extends Omit<StoryProps, 'setupApp'> {
+    /** A story with no `variants` and a `render` of its own has one implicit variant. */
+    variants?: VariantOptions<S>[];
+    render?: (api: ReactRenderApi<S>) => ReactNode;
+    initState?: () => Awaitable<S>;
+    setupApp?: ReactStorySetupHandler;
+}
+export declare function defineStory<S extends object = Record<string, any>>(story: StoryOptions<S>): StoryOptions<S>;
+export declare function defineSetupReact(handler: ReactStorySetupHandler): ReactStorySetupHandler;
+/** The variants a story declares, with the implicit one made explicit. */
+export declare function variantOptions(story: StoryOptions<any>): VariantOptions<any>[];

package/dist/types.js

@@ -0,0 +1,13 @@
+export function defineStory(story) {
+    return story;
+}
+export function defineSetupReact(handler) {
+    return handler;
+}
+/** The variants a story declares, with the implicit one made explicit. */
+export function variantOptions(story) {
+    if (story.variants?.length) {
+        return story.variants;
+    }
+    return story.render ? [{ id: '_default', title: 'default', render: story.render }] : [];
+}

package/package.json

@@ -1,9 +1,92 @@
 {
   "name": "@poveste/plugin-react",
-  "version": "0.0.1",
-  "description": "Placeholder. Install @poveste/plugin-react@0.19.0 or later.",
+  "type": "module",
+  "version": "0.19.0",
+  "description": "Poveste plugin for React support, renderer only",
+  "author": {
+    "name": "Sorin Gitlan",
+    "url": "https://x.com/50rayn"
+  },
   "license": "MIT",
-  "repository": { "type": "git", "url": "git+https://github.com/poveste-dev/poveste.git", "directory": "packages/poveste-plugin-react" },
-  "engines": { "node": ">=22.22.2" },
-  "publishConfig": { "access": "public" }
-}
+  "homepage": "https://poveste.dev",
+  "repository": {
+    "url": "https://github.com/poveste-dev/poveste.git",
+    "type": "git",
+    "directory": "packages/poveste-plugin-react"
+  },
+  "bugs": "https://github.com/poveste-dev/poveste/issues",
+  "keywords": [
+    "poveste",
+    "histoire",
+    "storybook",
+    "component-playground",
+    "component-explorer",
+    "stories",
+    "styleguide",
+    "design-system",
+    "vite",
+    "react",
+    "plugin"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    "./client": {
+      "types": "./dist/client/index.d.ts",
+      "default": "./dist/client/index.js"
+    },
+    "./collect": {
+      "types": "./dist/collect/index.d.ts",
+      "default": "./dist/collect/index.js"
+    },
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "client.d.ts",
+    "collect.d.ts",
+    "dist"
+  ],
+  "engines": {
+    "node": ">=22.22.2"
+  },
+  "peerDependencies": {
+    "@vitejs/plugin-react": "^6.0.0",
+    "poveste": "^0.19.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@vitejs/plugin-react": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "@poveste/shared": "^0.19.0",
+    "@poveste/vendors": "^0.19.0"
+  },
+  "devDependencies": {
+    "@types/node": "^26.6.3",
+    "@types/react": "^19.3.0",
+    "@types/react-dom": "^19.3.0",
+    "@vitejs/plugin-react": "^6.1.1",
+    "jsdom": "^30.1.1",
+    "poveste": "0.19.0",
+    "react": "^19.3.0",
+    "react-dom": "^19.3.0",
+    "typescript": "6.0.3",
+    "vite": "^8.3.1",
+    "vitest": "^5.0.2"
+  },
+  "scripts": {
+    "build": "rimraf dist && tsc -d",
+    "watch": "tsc -d -w --sourceMap",
+    "test": "vitest run"
+  }
+}