prev-cli 0.24.14 → 0.24.16

package/dist/jsx/adapters/html.d.ts

@@ -0,0 +1,15 @@
+import type { VNodeType } from '../vnode';
+import { type TokensConfig } from '../../tokens/resolver';
+export declare function setTokensConfig(tokens: TokensConfig | undefined): void;
+export interface RenderContext {
+    /** Current state for slot resolution */
+    state?: string;
+    /** Slots mapping: slotName -> stateName -> VNode */
+    slots?: Record<string, Record<string, VNodeType>>;
+    /** Callback to render component nodes */
+    renderComponent?: (name: string, props: Record<string, unknown>, children?: VNodeType[]) => string;
+}
+/**
+ * Render a VNode tree to HTML
+ */
+export declare function renderToHtml(node: VNodeType, context?: RenderContext): string;

package/dist/jsx/adapters/react.d.ts

@@ -0,0 +1,26 @@
+import React from 'react';
+import type { VNodeType } from '../vnode';
+export interface TokensConfig {
+    colors: Record<string, string>;
+    backgrounds: Record<string, string>;
+    spacing: Record<string, string>;
+    typography: {
+        sizes: Record<string, string>;
+        weights: Record<string, number>;
+    };
+    radius: Record<string, string>;
+    shadows: Record<string, string>;
+}
+export declare function setTokensConfig(tokens: TokensConfig | undefined): void;
+export interface ReactRenderContext {
+    /** Current state for slot resolution */
+    state?: string;
+    /** Slots mapping: slotName -> stateName -> VNode */
+    slots?: Record<string, Record<string, VNodeType>>;
+    /** Callback to render component nodes */
+    renderComponent?: (name: string, props: Record<string, unknown>, children?: React.ReactNode) => React.ReactNode;
+}
+/**
+ * Render a VNode tree to React elements
+ */
+export declare function toReact(node: VNodeType | VNodeType[], context?: ReactRenderContext): React.ReactNode;

package/dist/jsx/define-component.d.ts

@@ -0,0 +1,68 @@
+import { z } from 'zod';
+import { type VNodeType } from './vnode';
+/**
+ * Render context passed to component render function
+ */
+export interface ComponentContext<TProps, TState> {
+    props: TProps;
+    state: TState;
+}
+/**
+ * Component definition options
+ */
+export interface ComponentDefinition<TProps extends z.ZodType, TStates extends z.ZodType> {
+    /** Component name (used in VNode tree) */
+    name: string;
+    /** Zod schema for props */
+    props: TProps;
+    /** Zod schema for states */
+    states: TStates;
+    /** Default state value */
+    defaultState: z.infer<TStates>;
+    /** Render function that returns a VNode tree */
+    render: (ctx: ComponentContext<z.infer<TProps>, z.infer<TStates>>) => VNodeType;
+}
+/**
+ * Component function type returned by defineComponent
+ */
+export type ComponentFunction<TProps, TState> = {
+    (props: TProps, state?: TState): VNodeType;
+    componentName: string;
+    propsSchema: z.ZodType<TProps>;
+    statesSchema: z.ZodType<TState>;
+    defaultState: TState;
+};
+/**
+ * Define a reusable component with typed props and states
+ *
+ * @example
+ * ```tsx
+ * const Button = defineComponent({
+ *   name: 'Button',
+ *   props: z.object({
+ *     label: z.string(),
+ *     variant: z.enum(['primary', 'secondary']).optional(),
+ *   }),
+ *   states: z.enum(['idle', 'loading', 'disabled']),
+ *   defaultState: 'idle',
+ *   render: ({ props, state }) => (
+ *     <Box bg={state === 'loading' ? 'muted' : 'primary'} padding="md" radius="md">
+ *       <Text>{props.label}</Text>
+ *     </Box>
+ *   ),
+ * })
+ *
+ * // Usage
+ * <Button label="Click me" />
+ * <Button label="Processing..." state="loading" />
+ * ```
+ */
+export declare function defineComponent<TProps extends z.ZodType, TStates extends z.ZodType>(definition: ComponentDefinition<TProps, TStates>): ComponentFunction<z.infer<TProps>, z.infer<TStates>>;
+/**
+ * Helper to create a simple component without states
+ */
+export declare function defineStatelessComponent<TProps extends z.ZodType>(definition: {
+    name: string;
+    props: TProps;
+    render: (props: z.infer<TProps>) => VNodeType;
+}): (props: z.infer<TProps>) => VNodeType;

package/dist/jsx/index.d.ts

@@ -0,0 +1,7 @@
+export * from './schemas';
+export { createVNode, createComponentVNode, normalizeChildren, vnodeEquals, resetIdCounter, VNode, type VNodeType, } from './vnode';
+export { Col, Row, Box, Spacer, Slot, Text, Icon, Image, Fragment, } from './jsx-runtime';
+export { defineComponent, defineStatelessComponent, type ComponentContext, type ComponentDefinition, type ComponentFunction, } from './define-component';
+export { renderToHtml, type RenderContext } from './adapters/html';
+export { toReact, setTokensConfig, type ReactRenderContext, type TokensConfig } from './adapters/react';
+export { migrateYamlToJsx, type MigrationResult, type YamlConfig } from './migrate';

package/dist/jsx/jsx-runtime.d.ts

@@ -0,0 +1,34 @@
+import { type VNodeType } from './vnode';
+import { ColProps, RowProps, BoxProps, SpacerProps, SlotProps, TextProps, IconProps, ImageProps } from './schemas/primitives';
+export { setValidationMode, getValidationMode, type ValidationMode } from './validation';
+export declare function Col(props: ColProps): VNodeType;
+export declare function Row(props: RowProps): VNodeType;
+export declare function Box(props: BoxProps): VNodeType;
+export declare function Spacer(props?: SpacerProps): VNodeType;
+export declare function Slot(props: SlotProps): VNodeType;
+export declare function Text(props: TextProps): VNodeType;
+export declare function Icon(props: IconProps): VNodeType;
+export declare function Image(props: ImageProps): VNodeType;
+type JSXElementType = ((props: Record<string, unknown>, state?: unknown) => VNodeType) & {
+    statesSchema?: unknown;
+};
+/**
+ * JSX factory function - called for each JSX element
+ * Extracts `state` prop for components created with defineComponent
+ */
+export declare function jsx(type: JSXElementType, props: Record<string, unknown>): VNodeType;
+/**
+ * JSX factory for elements with static children
+ */
+export declare const jsxs: typeof jsx;
+/**
+ * JSX factory for development mode (with source info)
+ */
+export declare function jsxDEV(type: JSXElementType, props: Record<string, unknown>, _key?: string, _isStaticChildren?: boolean, _source?: {
+    fileName: string;
+    lineNumber: number;
+    columnNumber: number;
+}, _self?: unknown): VNodeType;
+export declare function Fragment({ children }: {
+    children?: unknown;
+}): VNodeType[];

package/dist/jsx/migrate.d.ts

@@ -0,0 +1,24 @@
+import type { TemplateNode, Slots } from '../primitives/types';
+export interface MigrationResult {
+    success: boolean;
+    jsx?: string;
+    errors: string[];
+}
+export interface YamlConfig {
+    kind: string;
+    id: string;
+    title: string;
+    schemaVersion?: string;
+    states?: Record<string, {
+        description?: string;
+    }>;
+    template?: {
+        root: TemplateNode;
+    };
+    slots?: Slots;
+    props?: Record<string, unknown>;
+}
+/**
+ * Migrate a YAML config file to JSX/TSX
+ */
+export declare function migrateYamlToJsx(yamlContent: string): MigrationResult;

package/dist/jsx/schemas/index.d.ts

@@ -0,0 +1,2 @@
+export * from './tokens';
+export * from './primitives';

package/dist/jsx/schemas/primitives.d.ts

@@ -0,0 +1,355 @@
+import { z } from 'zod';
+export declare const ColProps: z.ZodObject<{
+    gap: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        xs: "xs";
+        sm: "sm";
+        md: "md";
+        lg: "lg";
+        xl: "xl";
+        "2xl": "2xl";
+    }>>;
+    align: z.ZodOptional<z.ZodEnum<{
+        end: "end";
+        start: "start";
+        center: "center";
+        stretch: "stretch";
+        between: "between";
+    }>>;
+    padding: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        xs: "xs";
+        sm: "sm";
+        md: "md";
+        lg: "lg";
+        xl: "xl";
+        "2xl": "2xl";
+    }>>;
+    children: z.ZodOptional<z.ZodAny>;
+}, z.core.$strip>;
+export type ColProps = z.infer<typeof ColProps>;
+export declare const RowProps: z.ZodObject<{
+    gap: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        xs: "xs";
+        sm: "sm";
+        md: "md";
+        lg: "lg";
+        xl: "xl";
+        "2xl": "2xl";
+    }>>;
+    align: z.ZodOptional<z.ZodEnum<{
+        end: "end";
+        start: "start";
+        center: "center";
+        stretch: "stretch";
+        between: "between";
+    }>>;
+    padding: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        xs: "xs";
+        sm: "sm";
+        md: "md";
+        lg: "lg";
+        xl: "xl";
+        "2xl": "2xl";
+    }>>;
+    children: z.ZodOptional<z.ZodAny>;
+}, z.core.$strip>;
+export type RowProps = z.infer<typeof RowProps>;
+export declare const BoxProps: z.ZodObject<{
+    padding: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        xs: "xs";
+        sm: "sm";
+        md: "md";
+        lg: "lg";
+        xl: "xl";
+        "2xl": "2xl";
+    }>>;
+    bg: z.ZodOptional<z.ZodEnum<{
+        input: "input";
+        primary: "primary";
+        secondary: "secondary";
+        muted: "muted";
+        accent: "accent";
+        destructive: "destructive";
+        transparent: "transparent";
+        background: "background";
+        card: "card";
+    }>>;
+    radius: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        sm: "sm";
+        md: "md";
+        lg: "lg";
+        xl: "xl";
+        full: "full";
+    }>>;
+    children: z.ZodOptional<z.ZodAny>;
+}, z.core.$strip>;
+export type BoxProps = z.infer<typeof BoxProps>;
+export declare const SpacerProps: z.ZodObject<{
+    size: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        xs: "xs";
+        sm: "sm";
+        md: "md";
+        lg: "lg";
+        xl: "xl";
+        "2xl": "2xl";
+    }>>;
+}, z.core.$strip>;
+export type SpacerProps = z.infer<typeof SpacerProps>;
+export declare const SlotProps: z.ZodObject<{
+    name: z.ZodString;
+}, z.core.$strip>;
+export type SlotProps = z.infer<typeof SlotProps>;
+export declare const TextProps: z.ZodObject<{
+    children: z.ZodOptional<z.ZodString>;
+    size: z.ZodOptional<z.ZodEnum<{
+        base: "base";
+        xs: "xs";
+        sm: "sm";
+        lg: "lg";
+        xl: "xl";
+        "2xl": "2xl";
+    }>>;
+    weight: z.ZodOptional<z.ZodEnum<{
+        bold: "bold";
+        normal: "normal";
+        medium: "medium";
+        semibold: "semibold";
+    }>>;
+    color: z.ZodOptional<z.ZodEnum<{
+        foreground: "foreground";
+        "card-foreground": "card-foreground";
+        primary: "primary";
+        "primary-foreground": "primary-foreground";
+        secondary: "secondary";
+        "secondary-foreground": "secondary-foreground";
+        muted: "muted";
+        "muted-foreground": "muted-foreground";
+        accent: "accent";
+        "accent-foreground": "accent-foreground";
+        destructive: "destructive";
+        "destructive-foreground": "destructive-foreground";
+        border: "border";
+        ring: "ring";
+    }>>;
+}, z.core.$strip>;
+export type TextProps = z.infer<typeof TextProps>;
+export declare const IconProps: z.ZodObject<{
+    name: z.ZodString;
+    size: z.ZodOptional<z.ZodEnum<{
+        base: "base";
+        xs: "xs";
+        sm: "sm";
+        lg: "lg";
+        xl: "xl";
+        "2xl": "2xl";
+    }>>;
+    color: z.ZodOptional<z.ZodEnum<{
+        foreground: "foreground";
+        "card-foreground": "card-foreground";
+        primary: "primary";
+        "primary-foreground": "primary-foreground";
+        secondary: "secondary";
+        "secondary-foreground": "secondary-foreground";
+        muted: "muted";
+        "muted-foreground": "muted-foreground";
+        accent: "accent";
+        "accent-foreground": "accent-foreground";
+        destructive: "destructive";
+        "destructive-foreground": "destructive-foreground";
+        border: "border";
+        ring: "ring";
+    }>>;
+}, z.core.$strip>;
+export type IconProps = z.infer<typeof IconProps>;
+export declare const ImageProps: z.ZodObject<{
+    src: z.ZodString;
+    alt: z.ZodOptional<z.ZodString>;
+    fit: z.ZodOptional<z.ZodEnum<{
+        fill: "fill";
+        cover: "cover";
+        contain: "contain";
+    }>>;
+}, z.core.$strip>;
+export type ImageProps = z.infer<typeof ImageProps>;
+export declare const PrimitiveType: z.ZodEnum<{
+    component: "component";
+    text: "text";
+    slot: "slot";
+    col: "col";
+    row: "row";
+    box: "box";
+    spacer: "spacer";
+    icon: "icon";
+    image: "image";
+}>;
+export type PrimitiveType = z.infer<typeof PrimitiveType>;
+export declare const PrimitiveProps: z.ZodUnion<readonly [z.ZodObject<{
+    gap: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        xs: "xs";
+        sm: "sm";
+        md: "md";
+        lg: "lg";
+        xl: "xl";
+        "2xl": "2xl";
+    }>>;
+    align: z.ZodOptional<z.ZodEnum<{
+        end: "end";
+        start: "start";
+        center: "center";
+        stretch: "stretch";
+        between: "between";
+    }>>;
+    padding: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        xs: "xs";
+        sm: "sm";
+        md: "md";
+        lg: "lg";
+        xl: "xl";
+        "2xl": "2xl";
+    }>>;
+    children: z.ZodOptional<z.ZodAny>;
+}, z.core.$strip>, z.ZodObject<{
+    gap: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        xs: "xs";
+        sm: "sm";
+        md: "md";
+        lg: "lg";
+        xl: "xl";
+        "2xl": "2xl";
+    }>>;
+    align: z.ZodOptional<z.ZodEnum<{
+        end: "end";
+        start: "start";
+        center: "center";
+        stretch: "stretch";
+        between: "between";
+    }>>;
+    padding: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        xs: "xs";
+        sm: "sm";
+        md: "md";
+        lg: "lg";
+        xl: "xl";
+        "2xl": "2xl";
+    }>>;
+    children: z.ZodOptional<z.ZodAny>;
+}, z.core.$strip>, z.ZodObject<{
+    padding: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        xs: "xs";
+        sm: "sm";
+        md: "md";
+        lg: "lg";
+        xl: "xl";
+        "2xl": "2xl";
+    }>>;
+    bg: z.ZodOptional<z.ZodEnum<{
+        input: "input";
+        primary: "primary";
+        secondary: "secondary";
+        muted: "muted";
+        accent: "accent";
+        destructive: "destructive";
+        transparent: "transparent";
+        background: "background";
+        card: "card";
+    }>>;
+    radius: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        sm: "sm";
+        md: "md";
+        lg: "lg";
+        xl: "xl";
+        full: "full";
+    }>>;
+    children: z.ZodOptional<z.ZodAny>;
+}, z.core.$strip>, z.ZodObject<{
+    size: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        xs: "xs";
+        sm: "sm";
+        md: "md";
+        lg: "lg";
+        xl: "xl";
+        "2xl": "2xl";
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    name: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    children: z.ZodOptional<z.ZodString>;
+    size: z.ZodOptional<z.ZodEnum<{
+        base: "base";
+        xs: "xs";
+        sm: "sm";
+        lg: "lg";
+        xl: "xl";
+        "2xl": "2xl";
+    }>>;
+    weight: z.ZodOptional<z.ZodEnum<{
+        bold: "bold";
+        normal: "normal";
+        medium: "medium";
+        semibold: "semibold";
+    }>>;
+    color: z.ZodOptional<z.ZodEnum<{
+        foreground: "foreground";
+        "card-foreground": "card-foreground";
+        primary: "primary";
+        "primary-foreground": "primary-foreground";
+        secondary: "secondary";
+        "secondary-foreground": "secondary-foreground";
+        muted: "muted";
+        "muted-foreground": "muted-foreground";
+        accent: "accent";
+        "accent-foreground": "accent-foreground";
+        destructive: "destructive";
+        "destructive-foreground": "destructive-foreground";
+        border: "border";
+        ring: "ring";
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    name: z.ZodString;
+    size: z.ZodOptional<z.ZodEnum<{
+        base: "base";
+        xs: "xs";
+        sm: "sm";
+        lg: "lg";
+        xl: "xl";
+        "2xl": "2xl";
+    }>>;
+    color: z.ZodOptional<z.ZodEnum<{
+        foreground: "foreground";
+        "card-foreground": "card-foreground";
+        primary: "primary";
+        "primary-foreground": "primary-foreground";
+        secondary: "secondary";
+        "secondary-foreground": "secondary-foreground";
+        muted: "muted";
+        "muted-foreground": "muted-foreground";
+        accent: "accent";
+        "accent-foreground": "accent-foreground";
+        destructive: "destructive";
+        "destructive-foreground": "destructive-foreground";
+        border: "border";
+        ring: "ring";
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    src: z.ZodString;
+    alt: z.ZodOptional<z.ZodString>;
+    fit: z.ZodOptional<z.ZodEnum<{
+        fill: "fill";
+        cover: "cover";
+        contain: "contain";
+    }>>;
+}, z.core.$strip>]>;
+export type PrimitiveProps = z.infer<typeof PrimitiveProps>;

package/dist/jsx/schemas/tokens.d.ts

@@ -0,0 +1,79 @@
+import { z } from 'zod';
+export declare const SpacingToken: z.ZodEnum<{
+    none: "none";
+    xs: "xs";
+    sm: "sm";
+    md: "md";
+    lg: "lg";
+    xl: "xl";
+    "2xl": "2xl";
+}>;
+export type SpacingToken = z.infer<typeof SpacingToken>;
+export declare const AlignToken: z.ZodEnum<{
+    end: "end";
+    start: "start";
+    center: "center";
+    stretch: "stretch";
+    between: "between";
+}>;
+export type AlignToken = z.infer<typeof AlignToken>;
+export declare const BackgroundToken: z.ZodEnum<{
+    input: "input";
+    primary: "primary";
+    secondary: "secondary";
+    muted: "muted";
+    accent: "accent";
+    destructive: "destructive";
+    transparent: "transparent";
+    background: "background";
+    card: "card";
+}>;
+export type BackgroundToken = z.infer<typeof BackgroundToken>;
+export declare const RadiusToken: z.ZodEnum<{
+    none: "none";
+    sm: "sm";
+    md: "md";
+    lg: "lg";
+    xl: "xl";
+    full: "full";
+}>;
+export type RadiusToken = z.infer<typeof RadiusToken>;
+export declare const ColorToken: z.ZodEnum<{
+    foreground: "foreground";
+    "card-foreground": "card-foreground";
+    primary: "primary";
+    "primary-foreground": "primary-foreground";
+    secondary: "secondary";
+    "secondary-foreground": "secondary-foreground";
+    muted: "muted";
+    "muted-foreground": "muted-foreground";
+    accent: "accent";
+    "accent-foreground": "accent-foreground";
+    destructive: "destructive";
+    "destructive-foreground": "destructive-foreground";
+    border: "border";
+    ring: "ring";
+}>;
+export type ColorToken = z.infer<typeof ColorToken>;
+export declare const SizeToken: z.ZodEnum<{
+    base: "base";
+    xs: "xs";
+    sm: "sm";
+    lg: "lg";
+    xl: "xl";
+    "2xl": "2xl";
+}>;
+export type SizeToken = z.infer<typeof SizeToken>;
+export declare const WeightToken: z.ZodEnum<{
+    bold: "bold";
+    normal: "normal";
+    medium: "medium";
+    semibold: "semibold";
+}>;
+export type WeightToken = z.infer<typeof WeightToken>;
+export declare const FitToken: z.ZodEnum<{
+    fill: "fill";
+    cover: "cover";
+    contain: "contain";
+}>;
+export type FitToken = z.infer<typeof FitToken>;

package/dist/jsx/validation.d.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+/**
+ * Validation mode controls how schema validation behaves:
+ * - 'strict': throws on validation errors (useful for development/testing)
+ * - 'warn': logs warnings but continues (default in DEV)
+ * - 'off': no validation (default in production)
+ */
+export type ValidationMode = 'strict' | 'warn' | 'off';
+/**
+ * Set the validation mode for JSX primitives
+ * @param mode - The validation mode to use
+ */
+export declare function setValidationMode(mode: ValidationMode): void;
+/**
+ * Get the current validation mode
+ */
+export declare function getValidationMode(): ValidationMode;
+/**
+ * Validate props against a Zod schema based on current mode.
+ * In 'strict' mode, throws on error.
+ * In 'warn' mode, logs a warning and continues.
+ * In 'off' mode, skips validation entirely.
+ *
+ * @param schema - Zod schema to validate against
+ * @param props - Props to validate
+ * @param componentName - Component name for error messages
+ */
+export declare function validateProps(schema: z.ZodType, props: unknown, componentName: string): void;