@rsbuild/core 2.0.0-beta.5 → 2.0.0-beta.7

package/compiled/chokidar/index.d.ts

@@ -1,9 +1,175 @@
-/*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) */
 import { EventEmitter } from 'node:events';
-import { Stats } from 'node:fs';
-import { type EntryInfo, type ReaddirpOptions, ReaddirpStream } from 'readdirp';
-import { EVENTS as EV, type EventName, NodeFsHandler, type Path, type WatchHandlers } from './handler.js';
-export type AWF = {
+import { Dirent, Stats, WatchEventType } from 'node:fs';
+import { Readable } from 'node:stream';
+
+/**
+ * Recursive version of readdir. Exposes a streaming API and promise API.
+ * Streaming API allows to use a small amount of RAM.
+ *
+ * @module
+ * @example
+```js
+import readdirp from 'readdirp';
+for await (const entry of readdirp('.')) {
+  const {path} = entry;
+  console.log(`${JSON.stringify({path})}`);
+}
+```
+ */
+/*! readdirp - MIT License (c) 2012-2019 Thorsten Lorenz, Paul Miller (https://paulmillr.com) */
+
+/** Path in file system. */
+type Path$1 = string;
+/** Emitted entry. Contains relative & absolute path, basename, and either stats or dirent. */
+interface EntryInfo {
+    path: string;
+    fullPath: string;
+    stats?: Stats;
+    dirent?: Dirent;
+    basename: string;
+}
+/** Path or dir entries (files) */
+type PathOrDirent = Dirent | Path$1;
+/** Filterer for files */
+type Tester = (entryInfo: EntryInfo) => boolean;
+type Predicate = string[] | string | Tester;
+declare const EntryTypes: {
+    readonly FILE_TYPE: "files";
+    readonly DIR_TYPE: "directories";
+    readonly FILE_DIR_TYPE: "files_directories";
+    readonly EVERYTHING_TYPE: "all";
+};
+type EntryType = (typeof EntryTypes)[keyof typeof EntryTypes];
+/**
+ * Options for readdirp.
+ * * type: files, directories, or both
+ * * lstat: whether to use symlink-friendly stat
+ * * depth: max depth
+ * * alwaysStat: whether to use stat (more resources) or dirent
+ * * highWaterMark: streaming param, specifies max amount of resources per entry
+ */
+type ReaddirpOptions = {
+    root: string;
+    fileFilter?: Predicate;
+    directoryFilter?: Predicate;
+    type?: EntryType;
+    lstat?: boolean;
+    depth?: number;
+    alwaysStat?: boolean;
+    highWaterMark?: number;
+};
+/** Directory entry. Contains path, depth count, and files. */
+interface DirEntry$1 {
+    files: PathOrDirent[];
+    depth: number;
+    path: Path$1;
+}
+/** Readable readdir stream, emitting new files as they're being listed. */
+declare class ReaddirpStream extends Readable {
+    parents: any[];
+    reading: boolean;
+    parent?: DirEntry$1;
+    _stat: Function;
+    _maxDepth: number;
+    _wantsDir: boolean;
+    _wantsFile: boolean;
+    _wantsEverything: boolean;
+    _root: Path$1;
+    _isDirent: boolean;
+    _statsProp: 'dirent' | 'stats';
+    _rdOptions: {
+        encoding: 'utf8';
+        withFileTypes: boolean;
+    };
+    _fileFilter: Tester;
+    _directoryFilter: Tester;
+    constructor(options?: Partial<ReaddirpOptions>);
+    _read(batch: number): Promise<void>;
+    _exploreDir(path: Path$1, depth: number): Promise<{
+        files: string[] | undefined;
+        depth: number;
+        path: string;
+    }>;
+    _formatEntry(dirent: PathOrDirent, path: Path$1): Promise<EntryInfo | undefined>;
+    _onError(err: Error): void;
+    _getEntryType(entry: EntryInfo): Promise<void | '' | 'file' | 'directory'>;
+    _includeAsFile(entry: EntryInfo): boolean | undefined;
+}
+
+type Path = string;
+declare const EVENTS: {
+    readonly ALL: "all";
+    readonly READY: "ready";
+    readonly ADD: "add";
+    readonly CHANGE: "change";
+    readonly ADD_DIR: "addDir";
+    readonly UNLINK: "unlink";
+    readonly UNLINK_DIR: "unlinkDir";
+    readonly RAW: "raw";
+    readonly ERROR: "error";
+};
+type EventName = (typeof EVENTS)[keyof typeof EVENTS];
+interface WatchHandlers {
+    listener: (path: string) => void;
+    errHandler: (err: unknown) => void;
+    rawEmitter: (ev: WatchEventType, path: string, opts: unknown) => void;
+}
+/**
+ * @mixin
+ */
+declare class NodeFsHandler {
+    fsw: FSWatcher;
+    _boundHandleError: (error: unknown) => void;
+    constructor(fsW: FSWatcher);
+    /**
+     * Watch file for changes with fs_watchFile or fs_watch.
+     * @param path to file or dir
+     * @param listener on fs change
+     * @returns closer for the watcher instance
+     */
+    _watchWithNodeFs(path: string, listener: (path: string, newStats?: any) => void | Promise<void>): (() => void) | undefined;
+    /**
+     * Watch a file and emit add event if warranted.
+     * @returns closer for the watcher instance
+     */
+    _handleFile(file: Path, stats: Stats, initialAdd: boolean): (() => void) | undefined;
+    /**
+     * Handle symlinks encountered while reading a dir.
+     * @param entry returned by readdirp
+     * @param directory path of dir being read
+     * @param path of this item
+     * @param item basename of this item
+     * @returns true if no more processing is needed for this entry.
+     */
+    _handleSymlink(entry: EntryInfo, directory: string, path: Path, item: string): Promise<boolean | undefined>;
+    _handleRead(directory: string, initialAdd: boolean, wh: WatchHelper, target: Path | undefined, dir: Path, depth: number, throttler: Throttler): Promise<unknown> | undefined;
+    /**
+     * Read directory to add / remove files from `@watched` list and re-read it on change.
+     * @param dir fs path
+     * @param stats
+     * @param initialAdd
+     * @param depth relative to user-supplied path
+     * @param target child path targeted for watch
+     * @param wh Common watch helpers for this path
+     * @param realpath
+     * @returns closer for the watcher instance.
+     */
+    _handleDir(dir: string, stats: Stats, initialAdd: boolean, depth: number, target: string | undefined, wh: WatchHelper, realpath: string): Promise<(() => void) | undefined>;
+    /**
+     * Handle added file, directory, or glob pattern.
+     * Delegates call to _handleFile / _handleDir after checks.
+     * @param path to file or ir
+     * @param initialAdd was the file added at watch instantiation?
+     * @param priorWh depth relative to user-supplied path
+     * @param depth Child path actually targeted for watch
+     * @param target Child path actually targeted for watch
+     */
+    _addToNodeFs(path: string, initialAdd: boolean, priorWh: WatchHelper | undefined, depth: number, target?: string): Promise<string | false | undefined>;
+}
+
+/*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) */
+
+type AWF = {
     stabilityThreshold: number;
     pollInterval: number;
 };
@@ -20,29 +186,29 @@ type BasicOpts = {
     ignorePermissionErrors: boolean;
     atomic: boolean | number;
 };
-export type Throttler = {
+type Throttler = {
     timeoutObject: NodeJS.Timeout;
     clear: () => void;
     count: number;
 };
-export type ChokidarOptions = Partial<BasicOpts & {
+type ChokidarOptions = Partial<BasicOpts & {
     ignored: Matcher | Matcher[];
     awaitWriteFinish: boolean | Partial<AWF>;
 }>;
-export type FSWInstanceOptions = BasicOpts & {
+type FSWInstanceOptions = BasicOpts & {
     ignored: Matcher[];
     awaitWriteFinish: false | AWF;
 };
-export type ThrottleType = 'readdir' | 'watch' | 'add' | 'remove' | 'change';
-export type EmitArgs = [path: Path, stats?: Stats];
-export type EmitErrorArgs = [error: Error, stats?: Stats];
-export type EmitArgsWithName = [event: EventName, ...EmitArgs];
-export type MatchFunction = (val: string, stats?: Stats) => boolean;
-export interface MatcherObject {
+type ThrottleType = 'readdir' | 'watch' | 'add' | 'remove' | 'change';
+type EmitArgs = [path: Path, stats?: Stats];
+type EmitErrorArgs = [error: Error, stats?: Stats];
+type EmitArgsWithName = [event: EventName, ...EmitArgs];
+type MatchFunction = (val: string, stats?: Stats) => boolean;
+interface MatcherObject {
     path: string;
     recursive?: boolean;
 }
-export type Matcher = string | RegExp | MatchFunction | MatcherObject;
+type Matcher = string | RegExp | MatchFunction | MatcherObject;
 /**
  * Directory entry.
  */
@@ -57,7 +223,7 @@ declare class DirEntry {
     getChildren(): string[];
     dispose(): void;
 }
-export declare class WatchHelper {
+declare class WatchHelper {
     fsw: FSWatcher;
     path: string;
     watchPath: string;
@@ -70,16 +236,16 @@ export declare class WatchHelper {
     filterPath(entry: EntryInfo): boolean;
     filterDir(entry: EntryInfo): boolean;
 }
-export interface FSWatcherEventMap {
-    [EV.READY]: [];
-    [EV.RAW]: Parameters<WatchHandlers['rawEmitter']>;
-    [EV.ERROR]: Parameters<WatchHandlers['errHandler']>;
-    [EV.ALL]: [event: EventName, ...EmitArgs];
-    [EV.ADD]: EmitArgs;
-    [EV.CHANGE]: EmitArgs;
-    [EV.ADD_DIR]: EmitArgs;
-    [EV.UNLINK]: EmitArgs;
-    [EV.UNLINK_DIR]: EmitArgs;
+interface FSWatcherEventMap {
+    [EVENTS.READY]: [];
+    [EVENTS.RAW]: Parameters<WatchHandlers['rawEmitter']>;
+    [EVENTS.ERROR]: Parameters<WatchHandlers['errHandler']>;
+    [EVENTS.ALL]: [event: EventName, ...EmitArgs];
+    [EVENTS.ADD]: EmitArgs;
+    [EVENTS.CHANGE]: EmitArgs;
+    [EVENTS.ADD_DIR]: EmitArgs;
+    [EVENTS.UNLINK]: EmitArgs;
+    [EVENTS.UNLINK_DIR]: EmitArgs;
 }
 /**
  * Watches files & directories for changes. Emitted events:
@@ -89,7 +255,7 @@ export interface FSWatcherEventMap {
  *       .add(directories)
  *       .on('add', path => log('File', path, 'was added'))
  */
-export declare class FSWatcher extends EventEmitter<FSWatcherEventMap> {
+declare class FSWatcher extends EventEmitter<FSWatcherEventMap> {
     closed: boolean;
     options: FSWInstanceOptions;
     _closers: Map<string, Array<any>>;
@@ -209,9 +375,11 @@ export declare class FSWatcher extends EventEmitter<FSWatcherEventMap> {
  * const watcher = watch('.').on('all', (event, path) => { console.log(event, path); });
  * watch('.', { atomic: true, awaitWriteFinish: true, ignored: (f, stats) => stats?.isFile() && !f.endsWith('.js') })
  */
-export declare function watch(paths: string | string[], options?: ChokidarOptions): FSWatcher;
+declare function watch(paths: string | string[], options?: ChokidarOptions): FSWatcher;
 declare const _default: {
     watch: typeof watch;
     FSWatcher: typeof FSWatcher;
 };
-export default _default;
+
+export { FSWatcher, WatchHelper, _default as default, watch };
+export type { AWF, ChokidarOptions, EmitArgs, EmitArgsWithName, EmitErrorArgs, FSWInstanceOptions, FSWatcherEventMap, MatchFunction, Matcher, MatcherObject, ThrottleType, Throttler };

package/compiled/chokidar/package.json

@@ -1 +1 @@
-{"name":"chokidar","author":"Paul Miller (https://paulmillr.com)","version":"5.0.0","funding":"https://paulmillr.com/funding/","license":"MIT","type":"module"}
+{"name":"chokidar","author":"Paul Miller (https://paulmillr.com)","version":"5.0.0","funding":"https://paulmillr.com/funding/","license":"MIT","types":"index.d.ts","type":"module"}

package/compiled/connect/index.d.ts

@@ -0,0 +1,90 @@
+/// <reference types="node" />
+import * as http from 'http';
+
+/**
+ * Create a new connect server.
+ */
+declare function createServer(): createServer.Server;
+
+declare namespace createServer {
+    export type ServerHandle = HandleFunction | http.Server;
+
+    export class IncomingMessage extends http.IncomingMessage {
+        originalUrl?: http.IncomingMessage["url"] | undefined;
+    }
+
+    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 { createServer as default };

package/compiled/connect/license

@@ -0,0 +1,25 @@
+(The MIT License)
+
+Copyright (c) 2010 Sencha Inc.
+Copyright (c) 2011 LearnBoost
+Copyright (c) 2011-2014 TJ Holowaychuk
+Copyright (c) 2015 Douglas Christopher Wilson
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/compiled/connect/package.json

@@ -0,0 +1 @@
+{"name":"connect","author":"TJ Holowaychuk <tj@vision-media.ca> (http://tjholowaychuk.com)","version":"3.7.0","license":"MIT","types":"index.d.ts","type":"commonjs"}

package/compiled/cors/index.d.ts

@@ -0,0 +1,56 @@
+/// <reference types="node" />
+import { IncomingHttpHeaders } from 'http';
+
+type StaticOrigin = boolean | string | RegExp | Array<boolean | string | RegExp>;
+
+type CustomOrigin = (
+    requestOrigin: string | undefined,
+    callback: (err: Error | null, origin?: StaticOrigin) => void,
+) => void;
+
+declare namespace e {
+    interface CorsRequest {
+        method?: string | undefined;
+        headers: IncomingHttpHeaders;
+    }
+    interface CorsOptions {
+        /**
+         * @default '*'
+         */
+        origin?: StaticOrigin | CustomOrigin | undefined;
+        /**
+         * @default 'GET,HEAD,PUT,PATCH,POST,DELETE'
+         */
+        methods?: string | string[] | undefined;
+        allowedHeaders?: string | string[] | undefined;
+        exposedHeaders?: string | string[] | undefined;
+        credentials?: boolean | undefined;
+        maxAge?: number | undefined;
+        /**
+         * @default false
+         */
+        preflightContinue?: boolean | undefined;
+        /**
+         * @default 204
+         */
+        optionsSuccessStatus?: number | undefined;
+    }
+    type CorsOptionsDelegate<T extends CorsRequest = CorsRequest> = (
+        req: T,
+        callback: (err: Error | null, options?: CorsOptions) => void,
+    ) => void;
+}
+
+declare function e<T extends e.CorsRequest = e.CorsRequest>(
+    options?: e.CorsOptions | e.CorsOptionsDelegate<T>,
+): (
+    req: T,
+    res: {
+        statusCode?: number | undefined;
+        setHeader(key: string, value: string): any;
+        end(): any;
+    },
+    next: (err?: any) => any,
+) => void;
+
+export { e as default };

package/compiled/cors/license

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2013 Troy Goode <troygoode@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/compiled/cors/package.json

@@ -0,0 +1 @@
+{"name":"cors","author":"Troy Goode <troygoode@gmail.com> (https://github.com/troygoode/)","version":"2.8.6","funding":{"type":"opencollective","url":"https://opencollective.com/express"},"license":"MIT","types":"index.d.ts","type":"commonjs"}