@tempots/beatui 0.82.1 → 0.83.3

package/dist/types/components/theme/types.d.ts

@@ -1,30 +1,162 @@
 import { BackgroundColorName, ThemeColorName } from '../../tokens';
 import { Signal } from '@tempots/dom';
 import { AppearanceType } from '@tempots/ui';
-export type ButtonVariant = 'filled' | 'light' | 'outline' | 'default' | 'text';
+/**
+ * Visual style variant for button components.
+ * - `'filled'`: Solid background with theme color
+ * - `'light'`: Light background with colored text
+ * - `'outline'`: Transparent background with colored border
+ * - `'default'`: Default subtle styling
+ * - `'text'`: No background, text-only styling
+ */
+export type ButtonVariant = 'filled' | 'light' | 'outline' | 'dashed' | 'default' | 'text';
+/**
+ * Size options for form controls and interactive elements.
+ * Ranges from `'xs'` (extra small) to `'xl'` (extra large).
+ */
 export type ControlSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+/**
+ * Size options for icon elements.
+ * Ranges from `'xs'` (extra small) to `'xl'` (extra large).
+ */
 export type IconSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+/**
+ * Increases or decreases a size value by a specified number of steps.
+ * Automatically clamps the result to valid size boundaries.
+ *
+ * @param size - The current size value
+ * @param steps - Number of steps to increase (positive) or decrease (negative). Default is 1.
+ * @returns The new size value after adjustment
+ * @throws {Error} If the provided size is invalid
+ *
+ * @example
+ * ```ts
+ * increaseSize('sm', 1)  // Returns 'md'
+ * increaseSize('xl', 2)  // Returns 'xl' (clamped)
+ * increaseSize('lg', -2) // Returns 'sm'
+ * ```
+ */
 export declare function increaseSize(size: IconSize | ControlSize, steps?: number): "sm" | "md" | "lg" | "xl" | "xs";
+/**
+ * Visual effect for overlay backgrounds.
+ * - `'transparent'`: Semi-transparent background (e.g., modal backdrop)
+ * - `'opaque'`: Fully opaque background
+ * - `'none'`: No visual overlay effect
+ */
 export type OverlayEffect = 'transparent' | 'opaque' | 'none';
+/**
+ * Interaction mode for overlay elements.
+ * - `'capturing'`: Captures clicks and prevents interaction with underlying content
+ * - `'non-capturing'`: Allows click-through to underlying content
+ */
 export type OverlayMode = 'capturing' | 'non-capturing';
+/**
+ * State of a fade transition animation.
+ * - `'initial'`: Before animation begins
+ * - `'entering'`: Fade-in animation in progress
+ * - `'entered'`: Fade-in complete, element fully visible
+ * - `'exiting'`: Fade-out animation in progress
+ * - `'exited'`: Fade-out complete, element hidden
+ */
 export type FadeTransitionState = 'initial' | 'entering' | 'entered' | 'exiting' | 'exited';
+/**
+ * Specification for which sides of a box to apply styling (e.g., borders, padding).
+ * - `'left' | 'right' | 'top' | 'bottom'`: Single side
+ * - `'none'`: No sides
+ * - `'all'`: All four sides
+ * - Array of sides: Multiple specific sides
+ */
 export type Side = 'left' | 'right' | 'top' | 'bottom' | 'none' | 'all' | ('left' | 'right' | 'top' | 'bottom')[];
+/**
+ * Color options for panel components.
+ * Includes background color names, theme colors, and special values like `'white'`, `'black'`, and `'transparent'`.
+ */
 export type PanelColor = BackgroundColorName | ThemeColorName | 'white' | 'black' | 'transparent';
+/**
+ * Shadow intensity for panel components.
+ * Ranges from `'none'` (no shadow) to `'lg'` (large shadow).
+ */
 export type PanelShadow = 'none' | 'sm' | 'md' | 'lg';
+/**
+ * Semantic type for label text styling.
+ * - `'emphasis'`: High-contrast, emphasized text
+ * - `'default'`: Standard text appearance
+ * - `'muted'`: Low-contrast, de-emphasized text
+ * - `'danger'`: Error or warning styling
+ */
 export type LabelType = 'emphasis' | 'default' | 'muted' | 'danger';
+/**
+ * CSS `justify-content` property values for flexbox layouts.
+ * Controls alignment of flex items along the main axis.
+ */
 export type JustifyContent = 'flex-start' | 'flex-end' | 'safe flex-end' | 'center' | 'safe center' | 'space-between' | 'space-around' | 'space-evenly' | 'stretch' | 'baseline' | 'normal';
+/**
+ * CSS `justify-items` property values for grid layouts.
+ * Controls alignment of grid items along the inline (row) axis.
+ */
 export type JustifyItems = 'start' | 'end' | 'safe end' | 'center' | 'safe center' | 'stretch' | 'normal';
+/**
+ * CSS `justify-self` property values for individual grid/flex items.
+ * Controls alignment of a single item along the inline (row) axis.
+ */
 export type JustifySelf = 'auto' | 'start' | 'center' | 'safe center' | 'end' | 'safe end' | 'stretch';
+/**
+ * CSS `align-content` property values for multi-line flex containers.
+ * Controls alignment of flex lines along the cross axis.
+ */
 export type AlignContent = 'normal' | 'center' | 'flex-start' | 'flex-end' | 'space-between' | 'space-around' | 'space-evenly' | 'baseline' | 'stretch';
+/**
+ * CSS `align-items` property values for flexbox layouts.
+ * Controls alignment of flex items along the cross axis.
+ */
 export type AlignItems = 'flex-start' | 'flex-end' | 'safe flex-end' | 'center' | 'safe-center' | 'baseline' | 'last-baseline' | 'stretch';
+/**
+ * CSS `align-self` property values for individual flex/grid items.
+ * Controls alignment of a single item along the cross axis.
+ */
 export type AlignSelf = 'auto' | 'flex-start' | 'flex-end' | 'safe flex-end' | 'center' | 'safe center' | 'stretch' | 'baseline' | 'last baseline';
+/**
+ * Visual style variant for card components.
+ * - `'default'`: Standard card appearance
+ * - `'elevated'`: Card with shadow elevation
+ * - `'flat'`: Minimal card with no shadow
+ * - `'outlined'`: Card with border outline
+ */
 export type CardVariant = 'default' | 'elevated' | 'flat' | 'outlined';
+/**
+ * Gap spacing size for centered layouts.
+ * Ranges from `'none'` (no gap) to `'xl'` (extra large gap).
+ */
 export type CenterGap = 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+/**
+ * Visual depth variant for sink/inset components.
+ * - `'default'`: Standard inset depth
+ * - `'deep'`: Stronger inset effect
+ * - `'shallow'`: Subtle inset effect
+ * - `'flat'`: Minimal or no inset effect
+ */
 export type SinkVariant = 'default' | 'deep' | 'shallow' | 'flat';
+/**
+ * User's appearance preference setting.
+ * - `'light'`: Light theme
+ * - `'dark'`: Dark theme
+ * - `'system'`: Follow system preference
+ */
 export type AppearancePreference = 'light' | 'dark' | 'system';
+/**
+ * Resolved appearance mode (excludes system option).
+ * Either `'light'` or `'dark'`.
+ */
 export type Appearance = 'light' | 'dark';
+/**
+ * Theme context value provided by the Theme provider.
+ * Contains reactive signals for appearance state and a setter for user preferences.
+ */
 export interface ThemeValue {
+    /** Function to update the user's appearance preference. */
     setAppearancePreference: (appearance: AppearancePreference) => void;
+    /** Signal representing the user's selected appearance preference (including 'system'). */
     appearancePreference: Signal<AppearancePreference>;
+    /** Signal representing the resolved appearance mode ('light' or 'dark'). */
     appearance: Signal<AppearanceType>;
 }

package/dist/types/components/typography/index.d.ts

@@ -1 +1,2 @@
+export * from './kbd';
 export * from './label';

package/dist/types/components/typography/kbd.d.ts

@@ -0,0 +1,48 @@
+import { TNode, Value } from '@tempots/dom';
+/**
+ * Size variants for the keyboard key component.
+ *
+ * - `'xs'` - Extra small (12px)
+ * - `'sm'` - Small (14px, default)
+ * - `'md'` - Medium (16px)
+ */
+export type KbdSize = 'xs' | 'sm' | 'md';
+/**
+ * Configuration options for the {@link Kbd} component.
+ */
+export interface KbdOptions {
+    /** Size of the keyboard key element. @default 'sm' */
+    size?: Value<KbdSize>;
+}
+/**
+ * A styled keyboard key indicator component for displaying keyboard shortcuts.
+ * Renders keys with a 3D pressed appearance using monospace font.
+ *
+ * @param options - Configuration for size
+ * @param children - Key text content (e.g., "Ctrl", "⌘", "K")
+ * @returns A styled `<kbd>` element
+ *
+ * @example
+ * ```typescript
+ * // Single key
+ * Kbd({ size: 'sm' }, 'K')
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Keyboard shortcut combination
+ * html.span(
+ *   Kbd({}, '⌘'),
+ *   ' + ',
+ *   Kbd({}, 'K')
+ * )
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Different sizes
+ * Kbd({ size: 'xs' }, 'Esc')
+ * Kbd({ size: 'md' }, 'Enter')
+ * ```
+ */
+export declare function Kbd({ size }?: KbdOptions, ...children: TNode[]): import("@tempots/dom").Renderable;

package/dist/types/components/typography/label.d.ts

@@ -1,5 +1,50 @@
 import { TNode } from '@tempots/dom';
+/**
+ * Renders an emphasized inline label with stronger visual weight.
+ * Useful for highlighting important terms or key values.
+ *
+ * @param children - Content nodes to render inside the label span.
+ * @returns A `<span>` element with emphasis label styling.
+ *
+ * @example
+ * ```typescript
+ * html.p('Status: ', EmphasisLabel('Active'))
+ * ```
+ */
 export declare const EmphasisLabel: (...children: TNode[]) => import("@tempots/dom").Renderable;
+/**
+ * Renders a standard inline label with default text styling.
+ *
+ * @param children - Content nodes to render inside the label span.
+ * @returns A `<span>` element with default label styling.
+ *
+ * @example
+ * ```typescript
+ * html.p('Name: ', Label('John Doe'))
+ * ```
+ */
 export declare const Label: (...children: TNode[]) => import("@tempots/dom").Renderable;
+/**
+ * Renders a muted inline label with subdued color for secondary information.
+ *
+ * @param children - Content nodes to render inside the label span.
+ * @returns A `<span>` element with muted label styling.
+ *
+ * @example
+ * ```typescript
+ * html.p(Label('Primary info'), ' ', MutedLabel('(optional)'))
+ * ```
+ */
 export declare const MutedLabel: (...children: TNode[]) => import("@tempots/dom").Renderable;
+/**
+ * Renders a danger-styled inline label for error messages or destructive context.
+ *
+ * @param children - Content nodes to render inside the label span.
+ * @returns A `<span>` element with danger label styling.
+ *
+ * @example
+ * ```typescript
+ * html.p('Validation: ', DangerLabel('Required field'))
+ * ```
+ */
 export declare const DangerLabel: (...children: TNode[]) => import("@tempots/dom").Renderable;

package/dist/types/index.d.ts

@@ -1,3 +1,17 @@
+/**
+ * Main entry point for the `@tempots/beatui` component library.
+ *
+ * Exports all core UI components (buttons, forms, layout, overlays, navigation,
+ * typography, data display), the theme system, design tokens, i18n utilities,
+ * and helper functions. For optional modules (editors, auth, JSON schema), use
+ * the dedicated subpath imports.
+ *
+ * ```ts
+ * import { Button, TextInput, Modal, Theme } from '@tempots/beatui'
+ * ```
+ *
+ * @module
+ */
 export { Use } from '@tempots/dom';
 export * from './beatui-i18n';
 export * from './components/beatui';

package/dist/types/json-schema/index.d.ts

@@ -1 +1,14 @@
+/**
+ * JSON Schema form generation for `@tempots/beatui/json-schema`.
+ *
+ * Automatically generates validated form UIs from JSON Schema definitions.
+ * Supports custom widget registration, nested objects/arrays, conditional
+ * schemas, and integrates with BeatUI's form controller system.
+ *
+ * ```ts
+ * import { JsonSchemaForm } from '@tempots/beatui/json-schema'
+ * ```
+ *
+ * @module
+ */
 export * from '../components/json-schema';

package/dist/types/json-schema-display/index.d.ts

@@ -1 +1,13 @@
+/**
+ * Read-only JSON Schema display for `@tempots/beatui/json-schema-display`.
+ *
+ * Renders JSON Schema structures as formatted, non-editable documentation.
+ * Useful for API reference pages, schema explorers, and data dictionaries.
+ *
+ * ```ts
+ * import { JsonSchemaDisplay } from '@tempots/beatui/json-schema-display'
+ * ```
+ *
+ * @module
+ */
 export * from '../components/json-schema-display';

package/dist/types/json-structure/index.d.ts

@@ -1,9 +1,14 @@
 /**
- * JSON Structure Form Components
+ * JSON Structure form components for `@tempots/beatui/json-structure`.
  *
- * Entry point for the json-structure subpackage.
- * Import from '@tempots/beatui/json-structure'
+ * Provides form controls for editing structured JSON data with type-safe
+ * value handling, validation, and support for complex nested structures
+ * including objects, arrays, unions, and optional fields.
  *
- * @packageDocumentation
+ * ```ts
+ * import { JsonStructureForm } from '@tempots/beatui/json-structure'
+ * ```
+ *
+ * @module
  */
 export * from '../components/json-structure';

package/dist/types/markdown/index.d.ts

@@ -1,3 +1,16 @@
+/**
+ * Markdown rendering for `@tempots/beatui/markdown`.
+ *
+ * Renders Markdown content to styled HTML using micromark with optional
+ * GFM (GitHub Flavored Markdown) support. HTML is escaped by default
+ * for safety.
+ *
+ * ```ts
+ * import { Markdown } from '@tempots/beatui/markdown'
+ * ```
+ *
+ * @module
+ */
 import { TNode, Value, Renderable } from '@tempots/dom';
 export type MarkdownOptions = {
     content: Value<string>;

package/dist/types/monaco/index.d.ts

@@ -1,3 +1,20 @@
+/**
+ * Public entry point for the `@tempots/beatui/monaco` optional module.
+ *
+ * Re-exports the Monaco editor input component, type definitions, and the
+ * environment configuration helper. Monaco workers are configured
+ * automatically when the editor is first loaded via CDN.
+ *
+ * ```ts
+ * import {
+ *   MonacoEditorInput,
+ *   configureMonacoEnvironment,
+ *   type MonacoLanguage,
+ * } from '@tempots/beatui/monaco'
+ * ```
+ *
+ * @module
+ */
 export * from '../components/monaco/monaco-editor-input';
 export * from './types';
 export { configureMonacoEnvironment } from './lazy-loader';

package/dist/types/monaco/lazy-loader.d.ts

@@ -1,5 +1,84 @@
+/**
+ * Lazy loader for Monaco Editor via CDN (no bundler configuration required).
+ *
+ * Uses the AMD/RequireJS loader shipped with Monaco to load the editor and
+ * language-specific features on demand. The loaded instance is cached so
+ * subsequent calls return immediately.
+ *
+ * @module
+ */
 import type * as MonacoTypes from 'monaco-editor';
+/**
+ * Loads the core Monaco Editor API from CDN and returns the fully
+ * initialised `monaco` namespace. The result is cached so subsequent
+ * calls resolve immediately.
+ *
+ * Workers are configured automatically before the first load.
+ *
+ * @returns The Monaco Editor API namespace.
+ *
+ * @example
+ * ```ts
+ * const monaco = await loadMonacoCore()
+ * const editor = monaco.editor.create(container, { language: 'typescript' })
+ * ```
+ */
 export declare function loadMonacoCore(): Promise<typeof MonacoTypes>;
+/**
+ * Loads and configures language-specific features (validation, diagnostics,
+ * schemas) for the given language in Monaco.
+ *
+ * The core Monaco API is loaded first if not already available. Language
+ * loading promises are cached so each language is configured at most once.
+ *
+ * @param language - The Monaco language identifier (e.g. `'json'`, `'typescript'`, `'yaml'`).
+ *
+ * @example
+ * ```ts
+ * await loadLanguageFeatures('json')
+ * ```
+ */
 export declare function loadLanguageFeatures(language: string): Promise<void>;
+/**
+ * Loads the Monaco Editor API **and** the language-specific features for the
+ * given language in parallel, returning the fully initialised `monaco`
+ * namespace.
+ *
+ * This is the recommended loader for most use cases since it ensures both
+ * the core editor and language support are ready before the editor is created.
+ *
+ * @param language - The Monaco language identifier (e.g. `'json'`, `'typescript'`).
+ * @returns The Monaco Editor API namespace.
+ *
+ * @example
+ * ```ts
+ * const monaco = await loadMonacoWithLanguage('json')
+ * const editor = monaco.editor.create(el, { value: '{}', language: 'json' })
+ * ```
+ */
 export declare function loadMonacoWithLanguage(language: string): Promise<typeof MonacoTypes>;
+/**
+ * Configures the Monaco worker environment.
+ *
+ * Call this before creating any editor instances if you need custom web
+ * workers (e.g. bundled workers instead of CDN workers). When called without
+ * arguments, the default CDN-based worker environment is set up.
+ *
+ * This function is a no-op in non-browser environments (SSR).
+ *
+ * @param getWorkerFn - Optional factory that returns a `Worker` for a given
+ *   `workerId` and `label`. When omitted, the default AMD/CDN worker setup
+ *   is used.
+ *
+ * @example
+ * ```ts
+ * // Use default CDN workers
+ * configureMonacoEnvironment()
+ *
+ * // Use custom bundled workers
+ * configureMonacoEnvironment((workerId, label) => {
+ *   return new Worker(new URL('./my-worker.js', import.meta.url))
+ * })
+ * ```
+ */
 export declare function configureMonacoEnvironment(getWorkerFn?: (workerId: string, label: string) => Worker): void;

package/dist/types/monaco/styles-url.d.ts

@@ -1,2 +1,13 @@
+/**
+ * Resolves the Monaco editor CSS stylesheet as an absolute URL.
+ *
+ * In library builds, Vite inlines this as a `data:` URL so consumers do not
+ * need any additional asset configuration. The resulting URL is used by the
+ * `cssInjection: 'link'` option of {@link MonacoEditorInput} to lazily
+ * inject the stylesheet via a `<link>` element.
+ *
+ * @module
+ */
 declare const cssHref: string;
+/** Absolute URL pointing to the Monaco editor CSS stylesheet. */
 export default cssHref;

package/dist/types/monaco/styles.d.ts

@@ -1,2 +1,13 @@
+/**
+ * Bundles Monaco editor CSS as a JavaScript string for lazy, bundler-agnostic
+ * injection (e.g. via a `<style>` element).
+ *
+ * Vite resolves the CSS import at build time so consumers need no special
+ * asset configuration. **Do not** import this module except from inside a
+ * lazy code path to avoid pulling the CSS into the main bundle.
+ *
+ * @module
+ */
+/** The Monaco editor CSS stylesheet as an inlined string. */
 declare const _default: string;
 export default _default;

package/dist/types/monaco/types.d.ts

@@ -1,14 +1,61 @@
+/**
+ * Type definitions for Monaco Editor integration within BeatUI.
+ *
+ * @module
+ */
 import { Value } from '@tempots/dom';
+/**
+ * Supported language identifiers for the Monaco editor.
+ *
+ * Includes the most common built-in languages as literal types, but any
+ * valid Monaco language string is accepted.
+ *
+ * @example
+ * ```ts
+ * const lang: MonacoLanguage = 'typescript'
+ * ```
+ */
 export type MonacoLanguage = 'plaintext' | 'json' | 'yaml' | 'typescript' | 'javascript' | 'css' | 'html' | string;
+/**
+ * Describes a JSON Schema to be registered with the Monaco JSON language
+ * service for validation and autocompletion.
+ */
 export type MonacoJSONSchema = {
+    /** URI identifying this schema (e.g. `'http://myserver/schema.json'`). */
     uri: string;
+    /** Glob patterns of files this schema applies to (e.g. `['*.json']`). */
     fileMatch: string[];
+    /** The JSON Schema object itself (any valid JSON Schema draft). */
     schema: any;
 };
+/**
+ * Monaco-specific options used by {@link MonacoEditorInput} in addition to
+ * the standard BeatUI `InputOptions`.
+ */
 export type MonacoEditorSpecificOptions = {
+    /**
+     * The programming language for syntax highlighting and validation.
+     * @default 'plaintext'
+     */
     language?: Value<MonacoLanguage>;
+    /**
+     * Additional Monaco editor constructor options passed directly to
+     * `monaco.editor.create()`.
+     */
     editorOptions?: Record<string, unknown>;
+    /**
+     * JSON Schemas to register with the Monaco JSON language service.
+     * Only relevant when `language` is `'json'`.
+     */
     jsonSchemas?: Value<MonacoJSONSchema[]> | undefined;
+    /**
+     * Whether the editor should be read-only.
+     * @default false
+     */
     readOnly?: Value<boolean>;
+    /**
+     * Optional fetcher for external JSON/YAML schemas. Used by JSON via
+     * prefetch and by YAML via `schemaRequestService`.
+     */
     schemaRequest?: Value<((url: string) => Promise<string>) | undefined> | ((url: string) => Promise<string>) | undefined;
 };

package/dist/types/prosemirror/index.d.ts

@@ -1,2 +1,14 @@
+/**
+ * Public entry point for the `@tempots/beatui/prosemirror` optional module.
+ *
+ * Re-exports the ProseMirror markdown editor component and its toolbar so
+ * consumers can import them from a single path:
+ *
+ * ```ts
+ * import { ProseMirrorMarkdownInput, ProseMirrorToolbar } from '@tempots/beatui/prosemirror'
+ * ```
+ *
+ * @module
+ */
 export * from '../components/prosemirror/prosemirror-markdown-input';
 export * from '../components/prosemirror/prosemirror-toolbar';

package/dist/types/prosemirror/styles-url.d.ts

@@ -1,2 +1,13 @@
+/**
+ * Resolves the ProseMirror editor CSS stylesheet as an absolute URL.
+ *
+ * In library builds, Vite inlines this as a `data:` URL so consumers do not
+ * need any additional asset configuration. The resulting URL is used by the
+ * `cssInjection: 'link'` option of {@link ProseMirrorMarkdownInput} to
+ * lazily inject the stylesheet via a `<link>` element.
+ *
+ * @module
+ */
 declare const cssHref: string;
+/** Absolute URL pointing to the ProseMirror editor CSS stylesheet. */
 export default cssHref;

package/dist/types/prosemirror/styles.d.ts

@@ -1,2 +1,12 @@
+/**
+ * Bundles the ProseMirror editor CSS as a raw string for lazy, programmatic
+ * injection (e.g. via a `<style>` element).
+ *
+ * Vite inlines the CSS at build time so the string is available
+ * synchronously after a dynamic `import()` of this module.
+ *
+ * @module
+ */
+/** The ProseMirror editor CSS stylesheet as an inlined string. */
 declare const _default: string;
 export default _default;

package/dist/types/tailwind/google-fonts.d.ts

@@ -1,4 +1,19 @@
+/**
+ * Google Fonts download and caching utilities for the BeatUI Tailwind Vite plugin.
+ *
+ * Downloads Google Font CSS and font files at build time, rewrites URLs to
+ * local placeholders, and caches everything under `node_modules/.beatui/`
+ * so that fonts can be self-hosted in production builds.
+ *
+ * @module
+ */
+/**
+ * Font style values supported by Google Fonts.
+ */
 export type GoogleFontStyle = 'normal' | 'italic';
+/**
+ * CSS `font-display` strategy values supported by Google Fonts.
+ */
 export type GoogleFontDisplay = 'auto' | 'block' | 'swap' | 'fallback' | 'optional';
 export interface GoogleFontRequest {
     family: string;

package/dist/types/tailwind/index.d.ts

@@ -1,2 +1,15 @@
+/**
+ * Public entry point for the `@tempots/beatui/tailwind` optional module.
+ *
+ * Re-exports the BeatUI Tailwind CSS preset, the Vite plugin options type,
+ * and related utilities for integrating BeatUI's design token system with
+ * Tailwind CSS.
+ *
+ * ```ts
+ * import { createBeatuiPreset, beatuiPreset } from '@tempots/beatui/tailwind'
+ * ```
+ *
+ * @module
+ */
 export * from './preset';
 export type { BeatuiTailwindPluginOptions } from './vite-plugin';