@useavalon/avalon 0.1.23 → 0.1.24

package/dist/src/types/routing.d.ts

@@ -0,0 +1,297 @@
+/**
+ * Enhanced TypeScript support for file-system routing
+ *
+ * This module provides strongly typed interfaces, utility types, and type guards
+ * for the file-system routing system, ensuring type safety throughout the routing pipeline.
+ */
+import type { ComponentType } from 'preact';
+import type { LoaderContext, Metadata } from '../schemas/routing.ts';
+import type { LayoutConfig } from '../schemas/layout.ts';
+/**
+ * Extract route parameters from a route pattern string
+ *
+ * @example
+ * ```typescript
+ * type BlogParams = ExtractRouteParams<'/blog/[slug]'>; // { slug: string }
+ * type UserParams = ExtractRouteParams<'/users/[id]/posts/[postId]'>; // { id: string; postId: string }
+ * type CatchAllParams = ExtractRouteParams<'/docs/[...path]'>; // { path: string[] }
+ * ```
+ */
+export type ExtractRouteParams<T extends string> = T extends `${string}[${infer Param}]${infer Rest}` ? Param extends `...${infer RestParam}` ? {
+    [K in RestParam]: string[];
+} & ExtractRouteParams<Rest> : Param extends `${infer OptionalParam}?` ? {
+    [K in OptionalParam]?: string;
+} & ExtractRouteParams<Rest> : {
+    [K in Param]: string;
+} & ExtractRouteParams<Rest> : Record<PropertyKey, never>;
+/**
+ * Extract optional route parameters from a route pattern string
+ *
+ * @example
+ * ```typescript
+ * type OptionalParams = ExtractOptionalParams<'/blog/[[...slug]]'>; // { slug?: string[] }
+ * ```
+ */
+export type ExtractOptionalParams<T extends string> = T extends `${string}[[${infer Param}]]${infer Rest}` ? Param extends `...${infer RestParam}` ? {
+    [K in RestParam]?: string[];
+} & ExtractOptionalParams<Rest> : {
+    [K in Param]?: string;
+} & ExtractOptionalParams<Rest> : Record<PropertyKey, never>;
+/**
+ * Combine required and optional route parameters
+ */
+export type RouteParameters<T extends string> = ExtractRouteParams<T> & ExtractOptionalParams<T>;
+/**
+ * Strongly typed page component with route parameters
+ *
+ * @example
+ * ```typescript
+ * const BlogPost: TypedPageComponent<'/blog/[slug]'> = ({ params, query, data }) => {
+ *   // params.slug is typed as string
+ *   return <div>Blog post: {params.slug}</div>;
+ * };
+ * ```
+ */
+export type TypedPageComponent<TRoute extends string = string> = ComponentType<{
+    params: RouteParameters<TRoute>;
+    query: URLSearchParams;
+    data?: unknown;
+}>;
+/**
+ * Page component with custom data type
+ *
+ * @example
+ * ```typescript
+ * interface BlogPostData {
+ *   title: string;
+ *   content: string;
+ * }
+ *
+ * const BlogPost: TypedPageComponentWithData<'/blog/[slug]', BlogPostData> = ({ params, data }) => {
+ *   // data is typed as BlogPostData | undefined
+ *   return <div>{data?.title}</div>;
+ * };
+ * ```
+ */
+export type TypedPageComponentWithData<TRoute extends string, TData> = ComponentType<{
+    params: RouteParameters<TRoute>;
+    query: URLSearchParams;
+    data?: TData;
+}>;
+/**
+ * Strongly typed metadata generator function
+ *
+ * @example
+ * ```typescript
+ * const generateMetadata: TypedMetadataGenerator<'/blog/[slug]'> = async ({ slug }) => {
+ *   // slug is typed as string
+ *   return {
+ *     title: `Blog Post: ${slug}`,
+ *     description: `Read about ${slug}`,
+ *   };
+ * };
+ * ```
+ */
+export type TypedMetadataGenerator<TRoute extends string> = (params: RouteParameters<TRoute>) => Promise<Metadata>;
+/**
+ * Metadata generator with custom context
+ */
+export type TypedMetadataGeneratorWithContext<TRoute extends string, TContext = unknown> = (params: RouteParameters<TRoute>, context: TContext) => Promise<Metadata>;
+/**
+ * Strongly typed page loader function
+ *
+ * @example
+ * ```typescript
+ * const loader: TypedPageLoader<'/blog/[slug]', BlogPostData> = async ({ params, request }) => {
+ *   // params.slug is typed as string
+ *   const post = await fetchBlogPost(params.slug);
+ *   return post;
+ * };
+ * ```
+ */
+export type TypedPageLoader<TRoute extends string, TData = unknown> = (context: LoaderContext & {
+    params: RouteParameters<TRoute>;
+}) => Promise<TData>;
+/**
+ * Page loader with custom context
+ */
+export type TypedPageLoaderWithContext<TRoute extends string, TData = unknown, TContext = unknown> = (context: LoaderContext & {
+    params: RouteParameters<TRoute>;
+}, customContext: TContext) => Promise<TData>;
+/**
+ * Strongly typed route page module
+ *
+ * @example
+ * ```typescript
+ * const pageModule: TypedRoutePageModule<'/blog/[slug]', BlogPostData> = {
+ *   default: BlogPostComponent,
+ *   generateMetadata: async ({ slug }) => ({ title: slug }),
+ *   loader: async ({ params }) => fetchBlogPost(params.slug),
+ * };
+ * ```
+ */
+export type TypedRoutePageModule<TRoute extends string, TData = unknown> = {
+    default: TypedPageComponent<TRoute>;
+    layoutConfig?: LayoutConfig;
+    generateMetadata?: TypedMetadataGenerator<TRoute>;
+    loader?: TypedPageLoader<TRoute, TData>;
+};
+/**
+ * Strongly typed API handler function
+ *
+ * @example
+ * ```typescript
+ * export const GET: TypedApiHandler<'/api/users/[id]'> = async (request, { params }) => {
+ *   // params.id is typed as string
+ *   const user = await getUser(params.id);
+ *   return Response.json(user);
+ * };
+ * ```
+ */
+export type TypedApiHandler<TRoute extends string> = (request: Request, context: LoaderContext & {
+    params: RouteParameters<TRoute>;
+}) => Promise<Response>;
+/**
+ * Strongly typed API module with all HTTP methods
+ */
+export type TypedApiModule<TRoute extends string> = {
+    GET?: TypedApiHandler<TRoute>;
+    POST?: TypedApiHandler<TRoute>;
+    PUT?: TypedApiHandler<TRoute>;
+    DELETE?: TypedApiHandler<TRoute>;
+    PATCH?: TypedApiHandler<TRoute>;
+    HEAD?: TypedApiHandler<TRoute>;
+    OPTIONS?: TypedApiHandler<TRoute>;
+};
+/**
+ * Route pattern validation
+ */
+export type ValidRoutePattern<T extends string> = T extends `${string}[${string}]${string}` ? T : T extends `${string}(${string})${string}` ? T : T extends `${string}_${string}` ? never : T;
+/**
+ * Valid file extensions for routes
+ */
+export type ValidRouteExtension = '.tsx' | '.ts' | '.jsx' | '.js';
+/**
+ * Route file path validation
+ */
+export type ValidRouteFile<T extends string> = T extends `${string}${ValidRouteExtension}` ? T extends `${string}_${string}` ? never : T : never;
+/**
+ * Validate that a component accepts the correct props for a route
+ */
+export type ValidatePageComponent<TRoute extends string, TComponent> = TComponent extends ComponentType<infer TProps> ? TProps extends {
+    params: RouteParameters<TRoute>;
+} ? TComponent : never : never;
+/**
+ * Props validation for page components
+ */
+export interface PageComponentProps<TRoute extends string = string, TData = unknown> {
+    params: RouteParameters<TRoute>;
+    query: URLSearchParams;
+    data?: TData;
+}
+/**
+ * Validate page component props
+ */
+export type ValidatePageProps<TRoute extends string, TProps> = TProps extends PageComponentProps<TRoute> ? TProps : never;
+/**
+ * Check if a route has dynamic segments
+ */
+export type HasDynamicSegments<T extends string> = T extends `${string}[${string}]${string}` ? true : false;
+/**
+ * Check if a route has catch-all segments
+ */
+export type HasCatchAllSegments<T extends string> = T extends `${string}[...${string}]${string}` ? true : false;
+/**
+ * Check if a route has optional segments
+ */
+export type HasOptionalSegments<T extends string> = T extends `${string}[[${string}]]${string}` ? true : false;
+/**
+ * Get the static parts of a route
+ */
+export type GetStaticParts<T extends string> = T extends `${infer Static}[${string}]${infer Rest}` ? Static | GetStaticParts<Rest> : T;
+/**
+ * Count dynamic segments in a route
+ */
+export type CountDynamicSegments<T extends string, Count extends readonly unknown[] = []> = T extends `${string}[${string}]${infer Rest}` ? CountDynamicSegments<Rest, [...Count, unknown]> : Count['length'];
+/**
+ * Route error types
+ */
+export type RouteErrorType = 'ROUTE_NOT_FOUND' | 'INVALID_PARAMS' | 'LOADER_ERROR' | 'METADATA_ERROR' | 'COMPONENT_ERROR' | 'VALIDATION_ERROR';
+/**
+ * Route error with context
+ */
+export interface RouteError<TRoute extends string = string> {
+    type: RouteErrorType;
+    route: TRoute;
+    params?: Partial<RouteParameters<TRoute>>;
+    message: string;
+    originalError?: Error;
+    suggestions?: string[];
+}
+/**
+ * Error boundary props for routes
+ */
+export interface RouteErrorBoundaryProps<TRoute extends string = string> {
+    error: RouteError<TRoute>;
+    retry: () => void;
+    fallback?: ComponentType<{
+        error: RouteError<TRoute>;
+    }>;
+}
+/**
+ * Route debugging information
+ */
+export interface RouteDebugInfo<TRoute extends string = string> {
+    route: TRoute;
+    params: RouteParameters<TRoute>;
+    staticParts: string[];
+    dynamicSegments: string[];
+    hasOptionalSegments: HasOptionalSegments<TRoute>;
+    hasCatchAllSegments: HasCatchAllSegments<TRoute>;
+    priority: number;
+    filePath: string;
+}
+/**
+ * Route performance metrics
+ */
+export interface RoutePerformanceMetrics {
+    discoveryTime: number;
+    loadTime: number;
+    renderTime: number;
+    metadataResolutionTime: number;
+    cacheHits: number;
+    cacheMisses: number;
+}
+/**
+ * Type guard for route parameters
+ */
+export declare function isValidRouteParams<TRoute extends string>(params: unknown, expectedParams: (keyof RouteParameters<TRoute>)[]): params is RouteParameters<TRoute>;
+/**
+ * Type guard for page component props
+ */
+export declare function isValidPageProps<TRoute extends string>(props: unknown, expectedParams: (keyof RouteParameters<TRoute>)[]): props is PageComponentProps<TRoute>;
+/**
+ * Validate route pattern syntax
+ */
+export declare function isValidRoutePattern(pattern: string): boolean;
+/**
+ * Create a typed page component with parameter validation
+ */
+export declare function createTypedPageComponent<TRoute extends string>(component: TypedPageComponent<TRoute>, expectedParams: (keyof RouteParameters<TRoute>)[]): TypedPageComponent<TRoute>;
+/**
+ * Create a typed metadata generator with parameter validation
+ */
+export declare function createTypedMetadataGenerator<TRoute extends string>(generator: TypedMetadataGenerator<TRoute>, expectedParams: (keyof RouteParameters<TRoute>)[]): TypedMetadataGenerator<TRoute>;
+/**
+ * Create a typed page loader with parameter validation
+ */
+export declare function createTypedPageLoader<TRoute extends string, TData = unknown>(loader: TypedPageLoader<TRoute, TData>, expectedParams: (keyof RouteParameters<TRoute>)[]): TypedPageLoader<TRoute, TData>;
+/**
+ * Validate component accepts correct props for a route
+ */
+export declare function validatePageComponent<TRoute extends string>(component: unknown, _expectedParams: (keyof RouteParameters<TRoute>)[]): component is TypedPageComponent<TRoute>;
+/**
+ * Create a typed API handler with parameter validation
+ */
+export declare function createTypedApiHandler<TRoute extends string>(handler: TypedApiHandler<TRoute>, expectedParams: (keyof RouteParameters<TRoute>)[]): TypedApiHandler<TRoute>;
+export type { RouteParams, LoaderContext, Metadata, PageProps, RoutePageModule, FileSystemRoute, ResolvedMetadata, } from '../schemas/routing.ts';

package/dist/src/types/types.d.ts

@@ -0,0 +1,6 @@
+export type ImportConfig = {
+    names: string[];
+    from: string;
+};
+export type CleanupFunction = () => void;
+export * from './layout.ts';

package/dist/src/utils/dev-logger.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Dev-Only Logging Utilities
+ *
+ * These functions provide environment-aware logging that only outputs in development mode.
+ * In production (NODE_ENV=production), all logging is suppressed for better performance.
+ *
+ * @module dev-logger
+ */
+/**
+ * Check if we're in development mode
+ * Returns true if NODE_ENV is not set to "production"
+ */
+export declare function isDev(): boolean;
+/**
+ * Check if verbose logging is enabled
+ * Returns true only if AVALON_VERBOSE=1 is set
+ */
+export declare function isVerbose(): boolean;
+/**
+ * Log a message only in development mode AND when AVALON_VERBOSE=1 is set.
+ * By default this is a no-op — set AVALON_VERBOSE=1 to enable diagnostic output.
+ *
+ * @param args - Arguments to pass to console.log
+ */
+export declare function devLog(...args: unknown[]): void;
+/**
+ * Log a warning only in development mode
+ * In production, this is a no-op for performance
+ *
+ * @param args - Arguments to pass to console.warn
+ */
+export declare function devWarn(...args: unknown[]): void;
+/**
+ * Log an error only in development mode
+ * In production, this is a no-op for performance
+ *
+ * @param args - Arguments to pass to console.error
+ */
+export declare function devError(...args: unknown[]): void;
+/**
+ * Log render timing information for an island component
+ * Only logs in development mode AND when AVALON_VERBOSE=1 is set
+ * Warns when render time exceeds the threshold
+ *
+ * @param src - The island source path
+ * @param durationMs - The render duration in milliseconds
+ * @param threshold - Optional threshold for slow render warning (default: 100ms)
+ */
+export declare function logRenderTiming(src: string, durationMs: number, threshold?: number): void;
+/**
+ * Log a cache hit event (dev mode only)
+ *
+ * @param cacheType - The type of cache (e.g., 'analysis', 'path', 'framework')
+ * @param key - The cache key that was hit
+ */
+export declare function logCacheHit(cacheType: string, key: string): void;
+/**
+ * Log a cache miss event (dev mode only)
+ *
+ * @param cacheType - The type of cache (e.g., 'analysis', 'path', 'framework')
+ * @param key - The cache key that was missed
+ */
+export declare function logCacheMiss(cacheType: string, key: string): void;
+export declare class DevLogger {
+    private readonly tasks;
+    private spinnerInterval?;
+    private currentFrame;
+    private readonly startTime;
+    private readonly originalConsoleLog;
+    private readonly originalConsoleWarn;
+    private readonly originalConsoleError;
+    private readonly suppressedLogs;
+    private readonly headerLines;
+    constructor();
+    private suppressConsole;
+    restoreConsole(): void;
+    addTask(id: string, name: string): void;
+    startTask(id: string): void;
+    completeTask(id: string): void;
+    private render;
+    startSpinner(): void;
+    stopSpinner(): void;
+    finish(serverUrl: string, viteUrl?: string, hmrUrl?: string): void;
+}

package/dist/src/utils/fs.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Filesystem utilities for Avalon.
+ * Provides Node.js-compatible implementations of common filesystem
+ * functions used throughout the codebase.
+ */
+export interface WalkEntry {
+    path: string;
+    name: string;
+    isFile: boolean;
+    isDirectory: boolean;
+    isSymlink: boolean;
+}
+export interface WalkOptions {
+    maxDepth?: number;
+    includeFiles?: boolean;
+    includeDirs?: boolean;
+    includeSymlinks?: boolean;
+    match?: RegExp[];
+    skip?: RegExp[];
+    exts?: string[];
+}
+/**
+ * Walks a directory tree yielding entries, compatible with @std/fs walk().
+ */
+export declare function walk(root: string, options?: WalkOptions): AsyncIterableIterator<WalkEntry>;
+/**
+ * Ensures a directory exists, creating it recursively if needed.
+ */
+export declare function ensureDir(dir: string): Promise<void>;
+/**
+ * Check if a file or directory exists.
+ */
+export declare function exists(path: string): Promise<boolean>;
+/**
+ * Synchronous check if a file or directory exists.
+ */
+export declare function existsSync(path: string): boolean;
+/**
+ * Empties a directory by removing all contents.
+ */
+export declare function emptyDir(dir: string): Promise<void>;

package/dist/src/vite-plugin/auto-discover.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Auto-Discovery for Avalon Vite Plugin
+ *
+ * This module handles automatic discovery of framework integrations
+ * based on island prop usage in pages and layouts. It scans for components
+ * used with the `island` prop and detects their framework from file extensions
+ * and content.
+ */
+import type { IntegrationName } from "./types.ts";
+/**
+ * Discover integrations from files in the islands directory
+ *
+ * Scans the specified directory for component files and determines
+ * which framework integrations are needed based on file extensions
+ * and naming conventions.
+ *
+ * @param islandsDir - Path to the islands directory (relative or absolute)
+ * @param projectRoot - Optional project root for resolving relative paths
+ * @returns Set of discovered integration names
+ *
+ * @example
+ * ```ts
+ * const integrations = await discoverIntegrationsFromFiles("src/islands");
+ * // Returns Set { "vue", "svelte", "preact" } based on files found
+ * ```
+ */
+export declare function discoverIntegrationsFromFiles(islandsDir: string, projectRoot?: string): Promise<Set<IntegrationName>>;
+/**
+ * Detect the integration name from a file name
+ *
+ * Uses file extensions and naming conventions to determine
+ * which framework integration a component file belongs to.
+ *
+ * @param fileName - The file name to analyze
+ * @returns The integration name or null if not a supported component file
+ *
+ * @example
+ * ```ts
+ * detectIntegrationFromFileName("Counter.vue") // "vue"
+ * detectIntegrationFromFileName("Button.svelte") // "svelte"
+ * detectIntegrationFromFileName("Card.solid.tsx") // "solid"
+ * detectIntegrationFromFileName("Form.tsx") // "preact" (default)
+ * detectIntegrationFromFileName("styles.css") // null
+ * ```
+ */
+export declare function detectIntegrationFromFileName(fileName: string): IntegrationName | null;
+/**
+ * Check if a file extension is supported for island components
+ *
+ * @param extension - The file extension (including the dot)
+ * @returns True if the extension is supported
+ */
+export declare function isSupportedExtension(extension: string): boolean;
+/**
+ * Get all supported file extensions
+ *
+ * @returns Array of supported file extensions
+ */
+export declare function getSupportedExtensions(): readonly string[];
+/**
+ * Discover integrations by scanning pages and layouts for island prop usage.
+ *
+ * This function scans page and layout files for components used with the `island` prop,
+ * then resolves the import paths to detect which frameworks are needed.
+ *
+ * @param pagesDir - Path to the pages directory
+ * @param layoutsDir - Path to the layouts directory
+ * @param projectRoot - Optional project root for resolving relative paths
+ * @param modulesDir - Optional modules directory for modular architecture
+ * @returns Set of discovered integration names
+ */
+export declare function discoverIntegrationsFromIslandUsage(pagesDir: string, layoutsDir: string, projectRoot?: string, modulesDir?: string): Promise<Set<IntegrationName>>;

package/dist/src/vite-plugin/config.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Configuration Resolution for Avalon Vite Plugin
+ *
+ * This module provides default configuration values and the resolution
+ * function that merges user configuration with defaults.
+ */
+import type { AvalonPluginConfig, ResolvedAvalonConfig, ResolvedMDXConfig, ResolvedImageConfig } from "./types.ts";
+/**
+ * Default MDX configuration values
+ */
+export declare const DEFAULT_MDX_CONFIG: ResolvedMDXConfig;
+/**
+ * Default image optimization configuration values
+ */
+export declare const DEFAULT_IMAGE_CONFIG: ResolvedImageConfig;
+/**
+ * Default configuration values for the Avalon plugin
+ * These are used when the user doesn't provide specific values
+ */
+export declare const DEFAULT_CONFIG: Omit<ResolvedAvalonConfig, "isDev">;
+/**
+ * Default modules configuration values
+ */
+export declare const DEFAULT_MODULES_CONFIG: {
+    pagesDirName: string;
+    layoutsDirName: string;
+};
+/**
+ * Resolves user configuration by merging with defaults
+ *
+ * @param userConfig - Partial configuration provided by the user
+ * @param isDev - Whether the application is running in development mode
+ * @returns Fully resolved configuration with all defaults applied
+ *
+ * @example
+ * ```ts
+ * const resolved = resolveConfig({ integrations: ["react"] }, true);
+ * // resolved.pagesDir === "src/pages" (default)
+ * // resolved.integrations === ["react"] (user provided)
+ * // resolved.isDev === true
+ * ```
+ */
+export declare function resolveConfig(userConfig: AvalonPluginConfig | undefined, isDev: boolean): ResolvedAvalonConfig;
+/**
+ * Result of directory existence check
+ */
+export interface DirectoryCheckResult {
+    /** The directory path that was checked */
+    path: string;
+    /** The resolved absolute path */
+    absolutePath: string;
+    /** Whether the directory exists */
+    exists: boolean;
+    /** The type of directory (pages, layouts) */
+    type: "pages" | "layouts";
+}
+/**
+ * Check if configured directories exist and log warnings for missing ones
+ *
+ * This function checks if the configured directories (pagesDir, layoutsDir)
+ * exist on the filesystem. If a directory doesn't exist, it logs a warning but
+ * does NOT throw an error, allowing the application to continue.
+ *
+ * @param config - The resolved Avalon configuration
+ * @param projectRoot - The root directory of the project (defaults to process.cwd())
+ * @returns Array of directory check results
+ *
+ * @example
+ * ```ts
+ * const results = checkDirectoriesExist(resolvedConfig, '/path/to/project');
+ * // Logs warnings for any missing directories
+ * // Returns results for programmatic access
+ * ```
+ */
+export declare function checkDirectoriesExist(config: ResolvedAvalonConfig, projectRoot?: string): DirectoryCheckResult[];
+/**
+ * Log a summary of directory check results
+ *
+ * @param results - The directory check results
+ * @param verbose - Whether to log verbose output
+ */
+export declare function logDirectoryCheckSummary(results: DirectoryCheckResult[], verbose: boolean): void;

package/dist/src/vite-plugin/errors.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Error Classes for Avalon Vite Plugin
+ *
+ * This module provides custom error classes for configuration and integration errors.
+ * These errors include contextual information to help developers quickly identify
+ * and fix issues.
+ */
+/**
+ * Thrown when configuration is invalid
+ *
+ * This error includes the specific field name and value that caused the error,
+ * making it easier to identify and fix configuration issues.
+ *
+ * @example
+ * ```ts
+ * throw new AvalonConfigError(
+ *   "must be a valid directory path",
+ *   "islandsDir",
+ *   123 // invalid value - should be a string
+ * );
+ * // Error: Avalon configuration error in 'islandsDir': must be a valid directory path
+ * // Received value: 123
+ * ```
+ */
+export declare class AvalonConfigError extends Error {
+    /**
+     * The name of the configuration field that caused the error
+     */
+    readonly field: string;
+    /**
+     * The invalid value that was provided
+     */
+    readonly value: unknown;
+    constructor(message: string, field: string, value: unknown);
+}
+/**
+ * Thrown when an integration fails to load or has an invalid name
+ *
+ * This error includes the integration name and optionally the underlying cause,
+ * making it easier to diagnose integration loading issues.
+ *
+ * @example
+ * ```ts
+ * throw new IntegrationError(
+ *   "Failed to activate integration. Is @useavalon/react installed?",
+ *   "react",
+ *   originalError
+ * );
+ * // Error: Integration 'react': Failed to activate integration. Is @useavalon/react installed?
+ * ```
+ */
+export declare class IntegrationError extends Error {
+    /**
+     * The name of the integration that caused the error
+     */
+    readonly integrationName: string;
+    /**
+     * The original error that caused this error, if any
+     */
+    readonly originalCause?: Error;
+    constructor(message: string, integrationName: string, originalCause?: Error);
+}

package/dist/src/vite-plugin/image-optimization.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Image Optimization Plugin for Avalon
+ *
+ * Wraps vite-imagetools to provide automatic image optimization with
+ * sensible defaults for responsive images, modern formats, and srcset generation.
+ *
+ * Features:
+ * - Automatic WebP/AVIF conversion
+ * - Responsive srcset generation at multiple breakpoints
+ * - Metadata stripping for privacy
+ * - JSX component output for easy usage in islands
+ *
+ * Usage in components:
+ * ```tsx
+ * // Basic - returns optimized URL
+ * import heroImg from './hero.jpg?w=800&format=webp';
+ *
+ * // With srcset for responsive images
+ * import heroImg from './hero.jpg?w=400;800;1200&format=webp&as=srcset';
+ *
+ * // As JSX component (like Qwik's ?jsx)
+ * import HeroImage from './hero.jpg?w=1200&jsx';
+ * <HeroImage alt="Hero" />
+ * ```
+ */
+import type { Plugin } from 'vite';
+import type { ResolvedImageConfig } from './types.ts';
+/**
+ * Creates the vite-imagetools plugin with Avalon's configuration
+ */
+export declare function createImagePlugin(config: ResolvedImageConfig, verbose: boolean): Promise<Plugin[]>;
+/**
+ * Type declarations for image imports
+ * Users can reference these in their tsconfig.json
+ */
+export declare const IMAGE_TYPES_DECLARATION = "\ndeclare module '*.jpg' {\n  const src: string;\n  export default src;\n}\n\ndeclare module '*.jpeg' {\n  const src: string;\n  export default src;\n}\n\ndeclare module '*.png' {\n  const src: string;\n  export default src;\n}\n\ndeclare module '*.webp' {\n  const src: string;\n  export default src;\n}\n\ndeclare module '*.avif' {\n  const src: string;\n  export default src;\n}\n\ndeclare module '*.gif' {\n  const src: string;\n  export default src;\n}\n\ndeclare module '*?jsx' {\n  import type { ComponentType } from 'preact';\n  const Component: ComponentType<{ alt: string; class?: string; style?: Record<string, string> }>;\n  export default Component;\n}\n\ndeclare module '*&jsx' {\n  import type { ComponentType } from 'preact';\n  const Component: ComponentType<{ alt: string; class?: string; style?: Record<string, string> }>;\n  export default Component;\n}\n";