vite 3.1.7 → 3.2.0-beta.1

package/types/commonjs.d.ts

@@ -1,230 +1 @@
-/**
- * https://github.com/rollup/plugins/blob/master/packages/commonjs/types/index.d.ts
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file at
- * https://github.com/rollup/plugins/blob/master/LICENSE
- */
-export interface RollupCommonJSOptions {
-  /**
-   * A minimatch pattern, or array of patterns, which specifies the files in
-   * the build the plugin should operate on. By default, all files with
-   * extension `".cjs"` or those in `extensions` are included, but you can
-   * narrow this list by only including specific files. These files will be
-   * analyzed and transpiled if either the analysis does not find ES module
-   * specific statements or `transformMixedEsModules` is `true`.
-   * @default undefined
-   */
-  include?: string | RegExp | readonly (string | RegExp)[]
-  /**
-   * A minimatch pattern, or array of patterns, which specifies the files in
-   * the build the plugin should _ignore_. By default, all files with
-   * extensions other than those in `extensions` or `".cjs"` are ignored, but you
-   * can exclude additional files. See also the `include` option.
-   * @default undefined
-   */
-  exclude?: string | RegExp | readonly (string | RegExp)[]
-  /**
-   * For extensionless imports, search for extensions other than .js in the
-   * order specified. Note that you need to make sure that non-JavaScript files
-   * are transpiled by another plugin first.
-   * @default [ '.js' ]
-   */
-  extensions?: ReadonlyArray<string>
-  /**
-   * If true then uses of `global` won't be dealt with by this plugin
-   * @default false
-   */
-  ignoreGlobal?: boolean
-  /**
-   * If false, skips source map generation for CommonJS modules. This will
-   * improve performance.
-   * @default true
-   */
-  sourceMap?: boolean
-  /**
-   * Some `require` calls cannot be resolved statically to be translated to
-   * imports.
-   * When this option is set to `false`, the generated code will either
-   * directly throw an error when such a call is encountered or, when
-   * `dynamicRequireTargets` is used, when such a call cannot be resolved with a
-   * configured dynamic require target.
-   * Setting this option to `true` will instead leave the `require` call in the
-   * code or use it as a fallback for `dynamicRequireTargets`.
-   * @default false
-   */
-  ignoreDynamicRequires?: boolean
-  /**
-   * Instructs the plugin whether to enable mixed module transformations. This
-   * is useful in scenarios with modules that contain a mix of ES `import`
-   * statements and CommonJS `require` expressions. Set to `true` if `require`
-   * calls should be transformed to imports in mixed modules, or `false` if the
-   * `require` expressions should survive the transformation. The latter can be
-   * important if the code contains environment detection, or you are coding
-   * for an environment with special treatment for `require` calls such as
-   * ElectronJS. See also the `ignore` option.
-   * @default false
-   */
-  transformMixedEsModules?: boolean
-  /**
-   * By default, this plugin will try to hoist `require` statements as imports
-   * to the top of each file. While this works well for many code bases and
-   * allows for very efficient ESM output, it does not perfectly capture
-   * CommonJS semantics as the order of side effects like log statements may
-   * change. But it is especially problematic when there are circular `require`
-   * calls between CommonJS modules as those often rely on the lazy execution of
-   * nested `require` calls.
-   *
-   * Setting this option to `true` will wrap all CommonJS files in functions
-   * which are executed when they are required for the first time, preserving
-   * NodeJS semantics. Note that this can have an impact on the size and
-   * performance of the generated code.
-   *
-   * The default value of `"auto"` will only wrap CommonJS files when they are
-   * part of a CommonJS dependency cycle, e.g. an index file that is required by
-   * many of its dependencies. All other CommonJS files are hoisted. This is the
-   * recommended setting for most code bases.
-   *
-   * `false` will entirely prevent wrapping and hoist all files. This may still
-   * work depending on the nature of cyclic dependencies but will often cause
-   * problems.
-   *
-   * You can also provide a minimatch pattern, or array of patterns, to only
-   * specify a subset of files which should be wrapped in functions for proper
-   * `require` semantics.
-   *
-   * `"debug"` works like `"auto"` but after bundling, it will display a warning
-   * containing a list of ids that have been wrapped which can be used as
-   * minimatch pattern for fine-tuning.
-   * @default "auto"
-   */
-  strictRequires?: boolean | string | RegExp | readonly (string | RegExp)[]
-  /**
-   * Sometimes you have to leave require statements unconverted. Pass an array
-   * containing the IDs or a `id => boolean` function.
-   * @default []
-   */
-  ignore?: ReadonlyArray<string> | ((id: string) => boolean)
-  /**
-   * In most cases, where `require` calls are inside a `try-catch` clause,
-   * they should be left unconverted as it requires an optional dependency
-   * that may or may not be installed beside the rolled up package.
-   * Due to the conversion of `require` to a static `import` - the call is
-   * hoisted to the top of the file, outside of the `try-catch` clause.
-   *
-   * - `true`: All `require` calls inside a `try` will be left unconverted.
-   * - `false`: All `require` calls inside a `try` will be converted as if the
-   *   `try-catch` clause is not there.
-   * - `remove`: Remove all `require` calls from inside any `try` block.
-   * - `string[]`: Pass an array containing the IDs to left unconverted.
-   * - `((id: string) => boolean|'remove')`: Pass a function that control
-   *   individual IDs.
-   *
-   * @default false
-   */
-  ignoreTryCatch?:
-    | boolean
-    | 'remove'
-    | ReadonlyArray<string>
-    | ((id: string) => boolean | 'remove')
-  /**
-   * Controls how to render imports from external dependencies. By default,
-   * this plugin assumes that all external dependencies are CommonJS. This
-   * means they are rendered as default imports to be compatible with e.g.
-   * NodeJS where ES modules can only import a default export from a CommonJS
-   * dependency.
-   *
-   * If you set `esmExternals` to `true`, this plugins assumes that all
-   * external dependencies are ES modules and respect the
-   * `requireReturnsDefault` option. If that option is not set, they will be
-   * rendered as namespace imports.
-   *
-   * You can also supply an array of ids to be treated as ES modules, or a
-   * function that will be passed each external id to determine if it is an ES
-   * module.
-   * @default false
-   */
-  esmExternals?: boolean | ReadonlyArray<string> | ((id: string) => boolean)
-  /**
-   * Controls what is returned when requiring an ES module from a CommonJS file.
-   * When using the `esmExternals` option, this will also apply to external
-   * modules. By default, this plugin will render those imports as namespace
-   * imports i.e.
-   *
-   * ```js
-   * // input
-   * const foo = require('foo');
-   *
-   * // output
-   * import * as foo from 'foo';
-   * ```
-   *
-   * However there are some situations where this may not be desired.
-   * For these situations, you can change Rollup's behaviour either globally or
-   * per module. To change it globally, set the `requireReturnsDefault` option
-   * to one of the following values:
-   *
-   * - `false`: This is the default, requiring an ES module returns its
-   *   namespace. This is the only option that will also add a marker
-   *   `__esModule: true` to the namespace to support interop patterns in
-   *   CommonJS modules that are transpiled ES modules.
-   * - `"namespace"`: Like `false`, requiring an ES module returns its
-   *   namespace, but the plugin does not add the `__esModule` marker and thus
-   *   creates more efficient code. For external dependencies when using
-   *   `esmExternals: true`, no additional interop code is generated.
-   * - `"auto"`: This is complementary to how `output.exports: "auto"` works in
-   *   Rollup: If a module has a default export and no named exports, requiring
-   *   that module returns the default export. In all other cases, the namespace
-   *   is returned. For external dependencies when using `esmExternals: true`, a
-   *   corresponding interop helper is added.
-   * - `"preferred"`: If a module has a default export, requiring that module
-   *   always returns the default export, no matter whether additional named
-   *   exports exist. This is similar to how previous versions of this plugin
-   *   worked. Again for external dependencies when using `esmExternals: true`,
-   *   an interop helper is added.
-   * - `true`: This will always try to return the default export on require
-   *   without checking if it actually exists. This can throw at build time if
-   *   there is no default export. This is how external dependencies are handled
-   *   when `esmExternals` is not used. The advantage over the other options is
-   *   that, like `false`, this does not add an interop helper for external
-   *   dependencies, keeping the code lean.
-   *
-   * To change this for individual modules, you can supply a function for
-   * `requireReturnsDefault` instead. This function will then be called once for
-   * each required ES module or external dependency with the corresponding id
-   * and allows you to return different values for different modules.
-   * @default false
-   */
-  requireReturnsDefault?:
-    | boolean
-    | 'auto'
-    | 'preferred'
-    | 'namespace'
-    | ((id: string) => boolean | 'auto' | 'preferred' | 'namespace')
-
-  /**
-   * @default "auto"
-   */
-  defaultIsModuleExports?: boolean | 'auto' | ((id: string) => boolean | 'auto')
-  /**
-   * Some modules contain dynamic `require` calls, or require modules that
-   * contain circular dependencies, which are not handled well by static
-   * imports. Including those modules as `dynamicRequireTargets` will simulate a
-   * CommonJS (NodeJS-like)  environment for them with support for dynamic
-   * dependencies. It also enables `strictRequires` for those modules.
-   *
-   * Note: In extreme cases, this feature may result in some paths being
-   * rendered as absolute in the final bundle. The plugin tries to avoid
-   * exposing paths from the local machine, but if you are `dynamicRequirePaths`
-   * with paths that are far away from your project's folder, that may require
-   * replacing strings like `"/Users/John/Desktop/foo-project/"` -\> `"/"`.
-   */
-  dynamicRequireTargets?: string | ReadonlyArray<string>
-  /**
-   * To avoid long paths when using the `dynamicRequireTargets` option, you can use this option to specify a directory
-   * that is a common parent for all files that use dynamic require statements. Using a directory higher up such as `/`
-   * may lead to unnecessarily long paths in the generated code and may expose directory names on your machine like your
-   * home directory name. By default it uses the current working directory.
-   */
-  dynamicRequireRoot?: string
-}
+export type { RollupCommonJSOptions } from '../dist/node'

package/types/connect.d.ts

@@ -1,111 +1 @@
-// Inlined to avoid extra dependency
-// MIT Licensed https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/LICENSE
-
-// Type definitions for connect v3.4.0
-// Project: https://github.com/senchalabs/connect
-// Definitions by: Maxime LUCE <https://github.com/SomaticIT>
-//                 Evan Hahn <https://github.com/EvanHahn>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-
-/// <reference types="node" />
-import * as http from 'node:http'
-
-export namespace Connect {
-  export type ServerHandle = HandleFunction | http.Server
-
-  export class IncomingMessage extends http.IncomingMessage {
-    originalUrl?: http.IncomingMessage['url'] | undefined
-  }
-
-  export type NextFunction = (err?: any) => void
-
-  export type SimpleHandleFunction = (
-    req: IncomingMessage,
-    res: http.ServerResponse
-  ) => void
-  export type NextHandleFunction = (
-    req: IncomingMessage,
-    res: http.ServerResponse,
-    next: NextFunction
-  ) => void
-  export type ErrorHandleFunction = (
-    err: any,
-    req: IncomingMessage,
-    res: http.ServerResponse,
-    next: NextFunction
-  ) => void
-  export type HandleFunction =
-    | SimpleHandleFunction
-    | NextHandleFunction
-    | ErrorHandleFunction
-
-  export interface ServerStackItem {
-    route: string
-    handle: ServerHandle
-  }
-
-  export interface Server extends NodeJS.EventEmitter {
-    (req: http.IncomingMessage, res: http.ServerResponse, next?: Function): void
-
-    route: string
-    stack: ServerStackItem[]
-
-    /**
-     * Utilize the given middleware `handle` to the given `route`,
-     * defaulting to _/_. This "route" is the mount-point for the
-     * middleware, when given a value other than _/_ the middleware
-     * is only effective when that segment is present in the request's
-     * pathname.
-     *
-     * For example if we were to mount a function at _/admin_, it would
-     * be invoked on _/admin_, and _/admin/settings_, however it would
-     * not be invoked for _/_, or _/posts_.
-     */
-    use(fn: NextHandleFunction): Server
-    use(fn: HandleFunction): Server
-    use(route: string, fn: NextHandleFunction): Server
-    use(route: string, fn: HandleFunction): Server
-
-    /**
-     * Handle server requests, punting them down
-     * the middleware stack.
-     */
-    handle(
-      req: http.IncomingMessage,
-      res: http.ServerResponse,
-      next: Function
-    ): void
-
-    /**
-     * Listen for connections.
-     *
-     * This method takes the same arguments
-     * as node's `http.Server#listen()`.
-     *
-     * HTTP and HTTPS:
-     *
-     * If you run your application both as HTTP
-     * and HTTPS you may wrap them individually,
-     * since your Connect "server" is really just
-     * a JavaScript `Function`.
-     *
-     *      var connect = require('connect')
-     *        , http = require('http')
-     *        , https = require('https');
-     *
-     *      var app = connect();
-     *
-     *      http.createServer(app).listen(80);
-     *      https.createServer(options, app).listen(443);
-     */
-    listen(
-      port: number,
-      hostname?: string,
-      backlog?: number,
-      callback?: Function
-    ): http.Server
-    listen(port: number, hostname?: string, callback?: Function): http.Server
-    listen(path: string, callback?: Function): http.Server
-    listen(handle: any, listeningListener?: Function): http.Server
-  }
-}
+export type { Connect } from '../dist/node'

package/types/customEvent.d.ts

@@ -10,6 +10,11 @@ export interface CustomEventMap {
   'vite:beforePrune': PrunePayload
   'vite:beforeFullReload': FullReloadPayload
   'vite:error': ErrorPayload
+  'vite:invalidate': InvalidatePayload
+}
+
+export interface InvalidatePayload {
+  path: string
 }
 
 export type InferCustomEventPayload<T extends string> =

package/types/dynamicImportVars.d.ts

@@ -1,17 +1 @@
-export interface RollupDynamicImportVarsOptions {
-  /**
-   * Files to include in this plugin (default all).
-   * @default []
-   */
-  include?: string | RegExp | (string | RegExp)[]
-  /**
-   * Files to exclude in this plugin (default none).
-   * @default []
-   */
-  exclude?: string | RegExp | (string | RegExp)[]
-  /**
-   * By default, the plugin quits the build process when it encounters an error. If you set this option to true, it will throw a warning instead and leave the code untouched.
-   * @default false
-   */
-  warnOnError?: boolean
-}
+export type { RollupDynamicImportVarsOptions } from '../dist/node'

package/types/http-proxy.d.ts

@@ -1,250 +1 @@
-// Inlined to avoid extra dependency
-// MIT Licensed https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/LICENSE
-
-// Type definitions for node-http-proxy 1.17
-// Project: https://github.com/nodejitsu/node-http-proxy
-// Definitions by: Maxime LUCE <https://github.com/SomaticIT>
-//                 Florian Oellerich <https://github.com/Raigen>
-//                 Daniel Schmidt <https://github.com/DanielMSchmidt>
-//                 Jordan Abreu <https://github.com/jabreu610>
-//                 Samuel Bodin <https://github.com/bodinsamuel>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.1
-
-/// <reference types="node" />
-
-import type * as net from 'node:net'
-import type * as http from 'node:http'
-import * as events from 'node:events'
-import type * as url from 'node:url'
-import type * as stream from 'node:stream'
-
-export namespace HttpProxy {
-  export type ProxyTarget = ProxyTargetUrl | ProxyTargetDetailed
-
-  export type ProxyTargetUrl = string | Partial<url.Url>
-
-  export interface ProxyTargetDetailed {
-    host: string
-    port: number
-    protocol?: string | undefined
-    hostname?: string | undefined
-    socketPath?: string | undefined
-    key?: string | undefined
-    passphrase?: string | undefined
-    pfx?: Buffer | string | undefined
-    cert?: string | undefined
-    ca?: string | undefined
-    ciphers?: string | undefined
-    secureProtocol?: string | undefined
-  }
-
-  export type ErrorCallback = (
-    err: Error,
-    req: http.IncomingMessage,
-    res: http.ServerResponse,
-    target?: ProxyTargetUrl
-  ) => void
-
-  export class Server extends events.EventEmitter {
-    /**
-     * Creates the proxy server with specified options.
-     * @param options - Config object passed to the proxy
-     */
-    constructor(options?: ServerOptions)
-
-    /**
-     * Used for proxying regular HTTP(S) requests
-     * @param req - Client request.
-     * @param res - Client response.
-     * @param options - Additional options.
-     */
-    web(
-      req: http.IncomingMessage,
-      res: http.ServerResponse,
-      options?: ServerOptions,
-      callback?: ErrorCallback
-    ): void
-
-    /**
-     * Used for proxying regular HTTP(S) requests
-     * @param req - Client request.
-     * @param socket - Client socket.
-     * @param head - Client head.
-     * @param options - Additional options.
-     */
-    ws(
-      req: http.IncomingMessage,
-      socket: unknown,
-      head: unknown,
-      options?: ServerOptions,
-      callback?: ErrorCallback
-    ): void
-
-    /**
-     * A function that wraps the object in a webserver, for your convenience
-     * @param port - Port to listen on
-     */
-    listen(port: number): Server
-
-    /**
-     * A function that closes the inner webserver and stops listening on given port
-     */
-    close(callback?: () => void): void
-
-    /**
-     * Creates the proxy server with specified options.
-     * @param options - Config object passed to the proxy
-     * @returns Proxy object with handlers for `ws` and `web` requests
-     */
-    static createProxyServer(options?: ServerOptions): Server
-
-    /**
-     * Creates the proxy server with specified options.
-     * @param options - Config object passed to the proxy
-     * @returns Proxy object with handlers for `ws` and `web` requests
-     */
-    static createServer(options?: ServerOptions): Server
-
-    /**
-     * Creates the proxy server with specified options.
-     * @param options - Config object passed to the proxy
-     * @returns Proxy object with handlers for `ws` and `web` requests
-     */
-    static createProxy(options?: ServerOptions): Server
-
-    addListener(event: string, listener: () => void): this
-    on(event: string, listener: () => void): this
-    on(event: 'error', listener: ErrorCallback): this
-    on(
-      event: 'start',
-      listener: (
-        req: http.IncomingMessage,
-        res: http.ServerResponse,
-        target: ProxyTargetUrl
-      ) => void
-    ): this
-    on(
-      event: 'proxyReq',
-      listener: (
-        proxyReq: http.ClientRequest,
-        req: http.IncomingMessage,
-        res: http.ServerResponse,
-        options: ServerOptions
-      ) => void
-    ): this
-    on(
-      event: 'proxyRes',
-      listener: (
-        proxyRes: http.IncomingMessage,
-        req: http.IncomingMessage,
-        res: http.ServerResponse
-      ) => void
-    ): this
-    on(
-      event: 'proxyReqWs',
-      listener: (
-        proxyReq: http.ClientRequest,
-        req: http.IncomingMessage,
-        socket: net.Socket,
-        options: ServerOptions,
-        head: any
-      ) => void
-    ): this
-    on(
-      event: 'econnreset',
-      listener: (
-        err: Error,
-        req: http.IncomingMessage,
-        res: http.ServerResponse,
-        target: ProxyTargetUrl
-      ) => void
-    ): this
-    on(
-      event: 'end',
-      listener: (
-        req: http.IncomingMessage,
-        res: http.ServerResponse,
-        proxyRes: http.IncomingMessage
-      ) => void
-    ): this
-    on(
-      event: 'close',
-      listener: (
-        proxyRes: http.IncomingMessage,
-        proxySocket: net.Socket,
-        proxyHead: any
-      ) => void
-    ): this
-
-    once(event: string, listener: () => void): this
-    removeListener(event: string, listener: () => void): this
-    removeAllListeners(event?: string): this
-    getMaxListeners(): number
-    setMaxListeners(n: number): this
-    listeners(event: string): Array<() => void>
-    emit(event: string, ...args: any[]): boolean
-    listenerCount(type: string): number
-  }
-
-  export interface ServerOptions {
-    /** URL string to be parsed with the url module. */
-    target?: ProxyTarget | undefined
-    /** URL string to be parsed with the url module. */
-    forward?: ProxyTargetUrl | undefined
-    /** Object to be passed to http(s).request. */
-    agent?: any
-    /** Object to be passed to https.createServer(). */
-    ssl?: any
-    /** If you want to proxy websockets. */
-    ws?: boolean | undefined
-    /** Adds x- forward headers. */
-    xfwd?: boolean | undefined
-    /** Verify SSL certificate. */
-    secure?: boolean | undefined
-    /** Explicitly specify if we are proxying to another proxy. */
-    toProxy?: boolean | undefined
-    /** Specify whether you want to prepend the target's path to the proxy path. */
-    prependPath?: boolean | undefined
-    /** Specify whether you want to ignore the proxy path of the incoming request. */
-    ignorePath?: boolean | undefined
-    /** Local interface string to bind for outgoing connections. */
-    localAddress?: string | undefined
-    /** Changes the origin of the host header to the target URL. */
-    changeOrigin?: boolean | undefined
-    /** specify whether you want to keep letter case of response header key */
-    preserveHeaderKeyCase?: boolean | undefined
-    /** Basic authentication i.e. 'user:password' to compute an Authorization header. */
-    auth?: string | undefined
-    /** Rewrites the location hostname on (301 / 302 / 307 / 308) redirects, Default: null. */
-    hostRewrite?: string | undefined
-    /** Rewrites the location host/ port on (301 / 302 / 307 / 308) redirects based on requested host/ port.Default: false. */
-    autoRewrite?: boolean | undefined
-    /** Rewrites the location protocol on (301 / 302 / 307 / 308) redirects to 'http' or 'https'.Default: null. */
-    protocolRewrite?: string | undefined
-    /** rewrites domain of set-cookie headers. */
-    cookieDomainRewrite?:
-      | false
-      | string
-      | { [oldDomain: string]: string }
-      | undefined
-    /** rewrites path of set-cookie headers. Default: false */
-    cookiePathRewrite?:
-      | false
-      | string
-      | { [oldPath: string]: string }
-      | undefined
-    /** object with extra headers to be added to target requests. */
-    headers?: { [header: string]: string } | undefined
-    /** Timeout (in milliseconds) when proxy receives no response from target. Default: 120000 (2 minutes) */
-    proxyTimeout?: number | undefined
-    /** Timeout (in milliseconds) for incoming requests */
-    timeout?: number | undefined
-    /** Specify whether you want to follow redirects. Default: false */
-    followRedirects?: boolean | undefined
-    /** If set to true, none of the webOutgoing passes are called and it's your responsibility to appropriately return the response by listening and acting on the proxyRes event */
-    selfHandleResponse?: boolean | undefined
-    /** Buffer */
-    buffer?: stream.Stream | undefined
-  }
-}
+export type { HttpProxy } from '../dist/node'

package/types/importMeta.d.ts

@@ -4,11 +4,13 @@
 
 /* eslint-disable @typescript-eslint/consistent-type-imports */
 
-// Duplicate of import('../src/node/importGlob').GlobOptions in order to
-// avoid breaking the production client type. Because this file is referenced
-// in vite/client.d.ts and in production src/node/importGlob.ts doesn't exist.
-interface GlobOptions {
-  as?: string
+interface ImportMetaEnv {
+  [key: string]: any
+  BASE_URL: string
+  MODE: string
+  DEV: boolean
+  PROD: boolean
+  SSR: boolean
 }
 
 interface ImportMeta {
@@ -24,12 +26,3 @@ interface ImportMeta {
    */
   globEager: import('./importGlob').ImportGlobEagerFunction
 }
-
-interface ImportMetaEnv {
-  [key: string]: any
-  BASE_URL: string
-  MODE: string
-  DEV: boolean
-  PROD: boolean
-  SSR: boolean
-}

package/types/package.json

@@ -1,3 +1,3 @@
 {
-  "//": "this file is just here to make pnpm happy with --frozen-lockfile"
+  "//": "this file is here to make typescript happy when moduleResolution=node16+"
 }