or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

compatibility.mdcomponents.mdconfiguration-types.mdcore-types.mdhooks.mdindex.mdmodules.mdruntime-config.mdschema-validation.md
tile.json

tessl/npm-nuxt--schema

Nuxt types and default configuration providing comprehensive TypeScript types, schema definitions, and configuration system for the Nuxt framework.

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
npmpkg:npm/@nuxt/schema@4.1.x

To install, run

npx @tessl/cli install tessl/npm-nuxt--schema@4.1.0

index.mddocs/

@nuxt/schema

Overview

@nuxt/schema provides comprehensive TypeScript types, schema definitions, and default configuration for the Nuxt framework. It serves as the foundational type system that ensures type safety across the entire Nuxt ecosystem, defining interfaces for configuration options, hooks, modules, components, routing, and application structure.

Package Information

  • Name: @nuxt/schema
  • Type: TypeScript Library
  • Language: TypeScript
  • License: MIT

Installation

npm install @nuxt/schema
# or
pnpm add @nuxt/schema
# or
yarn add @nuxt/schema

Core Imports

// Import types
import type { 
  NuxtConfig, 
  NuxtOptions, 
  NuxtHooks,
  NuxtModule,
  RuntimeConfig 
} from '@nuxt/schema';

// Import default schema configuration
import NuxtConfigSchema from '@nuxt/schema';

// Import builder environment constants
import { builders } from '@nuxt/schema/builder-env';

Basic Usage

import type { NuxtConfig, NuxtModule } from '@nuxt/schema';

// Define a Nuxt configuration
const config: NuxtConfig = {
  modules: ['@nuxtjs/tailwindcss'],
  runtimeConfig: {
    apiSecret: 'secret-key',
    public: {
      apiBase: '/api'
    }
  }
};

// Create a Nuxt module with proper typing
const myModule: NuxtModule = {
  meta: {
    name: 'my-module',
    version: '1.0.0'
  },
  setup(options, nuxt) {
    // Module setup logic with full type safety
  }
};

Architecture

@nuxt/schema is organized into several key areas:

  • Configuration Types: Complete type definitions for Nuxt configuration
  • Core Types: Fundamental interfaces for Nuxt application structure
  • Hook System: Comprehensive hook definitions for extensibility
  • Module System: Type-safe module development interfaces
  • Schema Configuration: Default configuration resolvers and validation

Capabilities

Configuration System

The configuration system provides complete TypeScript coverage for all Nuxt configuration options, from basic app settings to advanced build configuration.

interface NuxtConfig extends DeepPartial<Omit<ConfigSchema, 'vue' | 'vite' | 'runtimeConfig' | 'webpack' | 'nitro'>> {
  vue?: Omit<DeepPartial<ConfigSchema['vue']>, 'config'> & { config?: Partial<Filter<VueAppConfig, string | boolean>> }
  vite?: ConfigSchema['vite']
  nitro?: NitroConfig
  runtimeConfig?: Overrideable<RuntimeConfig>
  webpack?: DeepPartial<ConfigSchema['webpack']> & {
    $client?: DeepPartial<ConfigSchema['webpack']>
    $server?: DeepPartial<ConfigSchema['webpack']>
  }
  $schema?: SchemaDefinition
}

Core Application Types

Essential interfaces that define the structure of Nuxt applications, including the main Nuxt instance, app interface, and plugin system.

interface Nuxt extends Hookable<NuxtHooks> {
  options: NuxtOptions
  hooks: Hookable<NuxtHooks>
  hook: Nuxt['hooks']['hook']
  callHook: Nuxt['hooks']['callHook']
  addHooks: Nuxt['hooks']['addHooks']
  ready: () => Promise<void>
  close: () => Promise<void>
  server?: any
  vfs: Record<string, string>
  apps: Record<string, NuxtApp>
}

Hook System

Comprehensive hook definitions that enable extensibility throughout the Nuxt lifecycle, from build-time to runtime.

type HookResult = Promise<void> | void

interface NuxtHooks {
  'kit:compatibility': (compatibility: NuxtCompatibility, issues: NuxtCompatibilityIssues) => HookResult
  'ready': (nuxt: Nuxt) => HookResult
  'close': (nuxt: Nuxt) => HookResult
  'restart': (options?: { hard?: boolean }) => HookResult
  // ... many more lifecycle hooks
}

Module Development

Type-safe interfaces for developing Nuxt modules, including module metadata, setup functions, and dependency management.

interface NuxtModule<TOptions = any, TSetupReturn = any> {
  meta?: ModuleMeta
  defaults?: TOptions | ((nuxt: Nuxt) => TOptions)
  schema?: TOptions
  hooks?: Partial<NuxtHooks>
  setup?: (
    this: void,
    resolvedOptions: TOptions,
    nuxt: Nuxt & { [key: string]: any }
  ) => Awaitable<TSetupReturn>
}

Component System

Type definitions for Nuxt's component auto-registration and management system.

interface Component {
  pascalName: string
  kebabName: string
  export: string
  filePath: string
  shortPath: string
  chunkName: string
  prefetch: boolean
  preload: boolean
  global?: boolean | 'sync'
  island?: boolean
  meta?: ComponentMeta
  mode?: 'client' | 'server' | 'all'
  priority?: number
}

Runtime Configuration

Type-safe runtime configuration system with environment variable support and public/private separation.

interface RuntimeConfig extends RuntimeConfigNamespace {
  app: NitroRuntimeConfigApp
  nitro?: NitroRuntimeConfig['nitro']
  public: PublicRuntimeConfig
}

type RuntimeValue<T, B extends string> = T & { [message]?: B }

Schema Validation

Default configuration schema and validation system that ensures proper Nuxt configuration.

const NuxtConfigSchema: SchemaDefinition

The schema includes configuration resolvers for all major Nuxt subsystems: app, build, dev, experimental, nitro, typescript, vite, webpack, and more.

Compatibility System

Module compatibility checking and validation system for ensuring proper module integration.

interface NuxtCompatibility {
  nuxt?: string
  builder?: Partial<Record<'vite' | 'webpack' | 'rspack' | (string & {}), false | string>>
}

This comprehensive type system enables full IntelliSense support and compile-time error checking across the entire Nuxt ecosystem, making it essential for any TypeScript-based Nuxt application or module development.