@vizejs/nuxt 0.310.0 → 0.315.1

package/dist/addons-ecITHT3X.d.mts

@@ -0,0 +1,369 @@
+import { NuxtLintConfigItem, NuxtLintFeatures } from "@vizejs/nuxt-lint-config";
+import { MuseaOptions } from "@vizejs/vite-plugin-musea";
+
+//#region src/compiler-options.d.ts
+type VizeNuxtPattern = string | RegExp;
+type VizeNuxtVueVersion = 0.11 | 1 | 2 | "2.7" | 3 | "legacy";
+interface VizeNuxtCompilerCompatibilityOptions {
+  vueVersion?: VizeNuxtVueVersion;
+  hostCompiler?: boolean;
+  scriptSetupInStandalone?: boolean;
+  optionsApiVapor?: boolean;
+  nuxtVersion?: 2 | 3 | 4;
+  webpackVersion?: 4 | 5;
+}
+interface VizeNuxtInspectorLintPlanRequest {
+  files: string[];
+  fresh: boolean;
+}
+interface VizeNuxtInspectorOptions {
+  lintPlan?: (request: VizeNuxtInspectorLintPlanRequest) => unknown;
+}
+/**
+ * Nuxt-facing mirror of the public `@vizejs/vite-plugin` options.
+ *
+ * Keeping this shape local lets the Nuxt module expose compiler configuration
+ * without requiring the sibling package's generated declaration files to exist
+ * during monorepo lint runs.
+ */
+interface VizeNuxtCompilerOptions {
+  /**
+   * Vue major version for the host project.
+   *
+   * Legacy Vue projects keep the host Vue compiler in charge. When set to
+   * `0.11`, `1`, `2`, `"2.7"`, or `"legacy"`, the underlying Vite plugin runs in
+   * compatibility mode and does not intercept `.vue` files.
+   */
+  vueVersion?: VizeNuxtVueVersion;
+  /**
+   * Opt-in compatibility features shared with `@vizejs/vite-plugin`.
+   */
+  compatibility?: VizeNuxtCompilerCompatibilityOptions;
+  /** Emit function-body output for CDN/global Vue evaluation. */
+  mode?: "module" | "function";
+  /** Module name for runtime imports. */
+  runtimeModuleName?: string;
+  /** Global variable name for standalone/function mode. */
+  runtimeGlobalName?: string;
+  /** Development inspector integrations forwarded to the Vite plugin. */
+  inspector?: VizeNuxtInspectorOptions;
+  /** Override the public base used for dev-time asset URLs. */
+  devUrlBase?: string;
+  /** Files to include in compilation. */
+  include?: VizeNuxtPattern | VizeNuxtPattern[];
+  /** Files to exclude from compilation. */
+  exclude?: VizeNuxtPattern | VizeNuxtPattern[];
+  /** Force production mode. */
+  isProduction?: boolean;
+  /** Enable SSR mode. */
+  ssr?: boolean;
+  /** Enable source map generation. */
+  sourceMap?: boolean;
+  /** Enable Vapor mode compilation. */
+  vapor?: boolean;
+  /**
+   * Default output mode for `.jsx`/`.tsx` components without a `"use vue:*"`
+   * directive (forwarded to the underlying Vize plugin). @default "vdom"
+   */
+  jsxMode?: "vdom" | "vapor";
+  /** Treat lowercase non-HTML tags as custom renderer elements. */
+  customRenderer?: boolean;
+  /** Template syntax compatibility mode. */
+  templateSyntax?: "standard" | "strict" | "quirks";
+  /** Root directory to scan for .vue files. */
+  root?: string;
+  /** Glob patterns to scan for .vue files during pre-compilation. */
+  scanPatterns?: string[];
+  /** Maximum number of Vue files to compile in a single native batch. */
+  precompileBatchSize?: number;
+  /** Glob patterns to ignore during pre-compilation. */
+  ignorePatterns?: string[];
+  /** Config file search mode. */
+  configMode?: "root" | "auto" | false;
+  /** Custom config file path. */
+  configFile?: string;
+  /**
+   * Handle .vue files in node_modules during on-demand compilation.
+   * @default true
+   */
+  handleNodeModulesVue?: boolean;
+  /** Enable debug logging. */
+  debug?: boolean;
+}
+//#endregion
+//#region src/lint/checker/options.d.ts
+/** Portable checker options mirrored from `@nuxt/eslint`. */
+interface VizeNuxtLintCheckerOptions {
+  /** Reuse the long-lived checker and lint only changed files after startup. */
+  cache?: boolean;
+  /** Files considered by the checker. */
+  include?: string[];
+  /** Files and directories excluded from checker runs. */
+  exclude?: string[];
+  /** Oxlint output formatter. */
+  formatter?: string;
+  /** Run a complete lint pass when the dev server starts. */
+  lintOnStart?: boolean;
+  /** Print warning diagnostics and surface them in the browser overlay. */
+  emitWarning?: boolean;
+  /** Print error diagnostics and surface them in the browser overlay. */
+  emitError?: boolean;
+  /** Apply safe fixes before reporting diagnostics. */
+  fix?: boolean;
+}
+/** Project paths used by upstream's checker defaults. */
+interface NuxtLintCheckerProject {
+  buildDir: string;
+  srcDir: string;
+}
+/** Fully defaulted checker options consumed by the worker integration. */
+interface ResolvedVizeNuxtLintCheckerOptions {
+  cache: boolean;
+  include: string[];
+  exclude: string[];
+  formatter: string;
+  lintOnStart: boolean;
+  emitWarning: boolean;
+  emitError: boolean;
+  fix: boolean;
+}
+/**
+ * Resolve the engine-neutral part of `@nuxt/eslint`'s checker contract.
+ *
+ * `configType` and `eslintPath` intentionally do not exist: they choose an
+ * ESLint implementation, while this checker always executes oxlint + Patina.
+ */
+declare function resolveNuxtLintCheckerOptions(checker: boolean | VizeNuxtLintCheckerOptions | undefined, project: NuxtLintCheckerProject): ResolvedVizeNuxtLintCheckerOptions | false;
+//#endregion
+//#region src/lint/options.d.ts
+interface VizeNuxtLintDevtoolsOptions {
+  /** Enable the inspector eagerly, lazily from its tab, or not at all. @default "lazy" */
+  enabled?: boolean | "lazy";
+  /** Localhost port for the in-process inspector UI. An available port is chosen by default. */
+  port?: number;
+}
+/** Options for the generated Nuxt-aware oxlint configuration. */
+interface VizeNuxtLintOptions extends NuxtLintFeatures {
+  /**
+   * File path for the generated oxlint config.
+   *
+   * Relative paths are resolved from the Nuxt project root.
+   * @default ".nuxt/oxlint.config.json"
+   */
+  configFile?: string;
+  /**
+   * Create a root `oxlint.config.mts` loading the generated config when no
+   * supported oxlint config exists in the project or an ancestor.
+   * @default true
+   */
+  autoInit?: boolean;
+  /**
+   * Override the directory the generated Nuxt globs are relative to.
+   * @default nuxt.options.rootDir
+   */
+  rootDir?: string;
+  /** Expose the resolved plan in a Nuxt DevTools tab. @default { enabled: "lazy" } */
+  devtools?: VizeNuxtLintDevtoolsOptions;
+}
+//#endregion
+//#region src/options.d.ts
+type VizeNuxtMajorVersion = 2 | 3 | 4;
+interface VizeNuxtCompatibilityOptions {
+  /**
+   * Override the detected Nuxt major version.
+   *
+   * This exists for projects with unusual module wrappers. Most projects should
+   * leave it on automatic detection.
+   */
+  nuxtVersion?: VizeNuxtMajorVersion;
+  /**
+   * Override the detected Vue major version.
+   *
+   * Nuxt 2 defaults to Vue 2 compatibility mode; Nuxt 3/4 defaults to Vue 3.
+   * Vue 0.11, Vue 1, and Vue 2 all use host-compiler compatibility mode.
+   */
+  vueVersion?: VizeNuxtVueVersion;
+  /**
+   * Keep legacy Vue projects on the host Vue compiler while still allowing the
+   * Vize Nuxt module to provide bridges, linting, type checking, and Musea.
+   *
+   * @default true for Vue 0.11, Vue 1, Vue 2, and Nuxt 2
+   */
+  hostCompiler?: boolean;
+  /**
+   * Allow registering the Vite compiler bridge even when Nuxt's builder
+   * detection cannot prove Vite support.
+   *
+   * @default false
+   */
+  forceViteCompiler?: boolean;
+  /**
+   * Enable function-body output for CDN/global Vue evaluation.
+   */
+  scriptSetupInStandalone?: boolean;
+  /**
+   * Allow Vapor output for Options API SFCs when the compiler is active.
+   */
+  optionsApiVapor?: boolean;
+  /**
+   * Preserve shared compatibility objects that also configure
+   * `@vizejs/unplugin/webpack`.
+   */
+  webpackVersion?: 4 | 5;
+}
+interface VizeNuxtBridgeOptions {
+  /**
+   * Re-apply Nuxt auto-import injection to Vize virtual Vue modules.
+   * @default true
+   */
+  autoImports?: boolean;
+  /**
+   * Re-apply Nuxt component auto-import resolution to Vize virtual Vue modules.
+   * @default true
+   */
+  components?: boolean;
+  /**
+   * Re-apply @nuxtjs/i18n helper injection to Vize virtual Vue modules.
+   * @default true
+   */
+  i18n?: boolean;
+  /**
+   * Stabilize Nuxt generated async-data keys between client and SSR transforms.
+   * @default true
+   */
+  stableInjectedKeys?: boolean;
+}
+interface VizeNuxtUnoCssOptions {
+  /**
+   * Feed the original .vue source to UnoCSS extraction-only plugins so
+   * attributify syntax survives Vize's render-function output.
+   *
+   * Set to `false` to skip reading SFC source files. Use an object to tune the
+   * maximum source size read into Node.
+   *
+   * @default true
+   */
+  originalSource?: boolean | {
+    /**
+     * Maximum original .vue source size to append for UnoCSS extraction.
+     * @default 2097152
+     */
+    maxBytes?: number;
+  };
+}
+interface VizeNuxtDevOptions {
+  /**
+   * Remove broken duplicate/unsafe stylesheet links from Nuxt dev SSR HTML
+   * when Vize is the Vue compiler.
+   *
+   * @default true
+   */
+  stylesheetLinks?: boolean;
+}
+interface NuxtMuseaOptions {
+  route?: {
+    path?: string;
+    name?: string;
+    params?: Record<string, string>;
+    query?: Record<string, string>;
+    hash?: string;
+    fullPath?: string;
+    meta?: Record<string, unknown>;
+  };
+  runtimeConfig?: {
+    public?: Record<string, unknown>;
+    [key: string]: unknown;
+  };
+  fetchMocks?: Record<string, unknown>;
+  stateMocks?: Record<string, unknown>;
+}
+interface VizeNuxtOptions {
+  /**
+   * Host framework compatibility overrides.
+   *
+   * These are usually inferred from Nuxt itself. Set `vueVersion: 0.11`, `1`,
+   * `2`, or `"legacy"` for setups that must keep the host compiler.
+   */
+  compatibility?: VizeNuxtCompatibilityOptions;
+  /**
+   * Enable/disable the Vize compiler (Vue SFC compilation via Vite plugin).
+   * Pass an object to configure the underlying `@vizejs/vite-plugin`.
+   *
+   * @default true
+   */
+  compiler?: boolean | VizeNuxtCompilerOptions;
+  /**
+   * Nuxt compatibility bridges for transforms that normally skip Rollup
+   * virtual module ids.
+   *
+   * @default true
+   */
+  bridge?: boolean | VizeNuxtBridgeOptions;
+  /**
+   * UnoCSS bridge options for Vize virtual Vue modules.
+   *
+   * @default true
+   */
+  unocss?: boolean | VizeNuxtUnoCssOptions;
+  /**
+   * Dev-server integration options.
+   */
+  dev?: VizeNuxtDevOptions;
+  /**
+   * Generate the Nuxt-aware oxlint config consumed by Vize's linting engine.
+   * @default true
+   */
+  lint?: boolean | VizeNuxtLintOptions;
+  /** Run oxlint + Patina beside the dev server. @default false */
+  checker?: boolean | VizeNuxtLintCheckerOptions;
+  /**
+   * Musea gallery options.
+   * Set to `true` to enable Musea with default options.
+   *
+   * @default false
+   */
+  musea?: boolean | MuseaOptions;
+  /**
+   * Nuxt mock options for musea gallery.
+   * NOTE: In Nuxt context, nuxtMusea mocks are NOT added as a global Vite plugin
+   * because they would intercept `#imports` resolution and break Nuxt's internals.
+   * Real Nuxt composables are available via Nuxt's own plugin pipeline.
+   */
+  nuxtMusea?: NuxtMuseaOptions;
+}
+//#endregion
+//#region src/lint/addons.d.ts
+/** Hook other Nuxt modules use to extend Vize's generated lint config. */
+declare const VIZE_NUXT_LINT_CONFIG_ADDONS_HOOK: "vize:lint:config:addons";
+/** A synchronous or asynchronous addon result, matching Nuxt hook conventions. */
+type NuxtLintAwaitable<T> = T | Promise<T>;
+/** The import identity exposed by Nuxt and Nitro's unimport registries. */
+interface NuxtLintImport {
+  from: string;
+  name: string;
+  as?: string;
+}
+/** One extension of the generated, engine-neutral lint config plan. */
+interface NuxtLintConfigAddon {
+  name: string;
+  getConfigs(): NuxtLintAwaitable<readonly NuxtLintConfigItem[] | undefined>;
+}
+/** The Nuxt hook surface used by lint config addons. */
+interface NuxtLintConfigAddonNuxt {
+  hook(name: "imports:context" | "nitro:init", callback: (value: unknown) => unknown): void;
+  callHook(name: typeof VIZE_NUXT_LINT_CONFIG_ADDONS_HOOK, addons: NuxtLintConfigAddon[]): NuxtLintAwaitable<void>;
+}
+/** Resolve the config items contributed by the current addon registry. */
+type ResolveNuxtLintConfigAddons = () => Promise<readonly NuxtLintConfigItem[]>;
+/**
+ * Register the built-in auto-import addon and return the generation-time
+ * resolver consumed by the Nuxt lint config writer.
+ *
+ * The addon array is rebuilt for every generation. This mirrors Nuxt's addon
+ * hook without retaining contributions across `builder:generateApp` runs.
+ * The Vize-namespaced hook carries engine-neutral config items instead of raw
+ * ESLint source, so contributors remain compatible with the oxlint emitter.
+ */
+declare function setupNuxtLintConfigAddons(nuxt: NuxtLintConfigAddonNuxt): ResolveNuxtLintConfigAddons;
+//#endregion
+export { VizeNuxtLintCheckerOptions as _, ResolveNuxtLintConfigAddons as a, VizeNuxtCompilerOptions as b, NuxtMuseaOptions as c, VizeNuxtDevOptions as d, VizeNuxtMajorVersion as f, ResolvedVizeNuxtLintCheckerOptions as g, VizeNuxtLintOptions as h, NuxtLintImport as i, VizeNuxtBridgeOptions as l, VizeNuxtUnoCssOptions as m, NuxtLintConfigAddon as n, VIZE_NUXT_LINT_CONFIG_ADDONS_HOOK as o, VizeNuxtOptions as p, NuxtLintConfigAddonNuxt as r, setupNuxtLintConfigAddons as s, NuxtLintAwaitable as t, VizeNuxtCompatibilityOptions as u, resolveNuxtLintCheckerOptions as v, VizeNuxtVueVersion as x, VizeNuxtCompilerCompatibilityOptions as y };