@rsbuild/core 2.0.0-alpha.0 → 2.0.0-alpha.2

package/compiled/chokidar/handler.d.ts

@@ -0,0 +1,90 @@
+import type { FSWatcher as NativeFsWatcher, Stats, WatchEventType } from 'node:fs';
+import type { EntryInfo } from 'readdirp';
+import type { FSWatcher, Throttler, WatchHelper } from './index.js';
+export type Path = string;
+export declare const STR_DATA = "data";
+export declare const STR_END = "end";
+export declare const STR_CLOSE = "close";
+export declare const EMPTY_FN: () => void;
+export declare const IDENTITY_FN: (val: unknown) => unknown;
+export declare const isWindows: boolean;
+export declare const isMacos: boolean;
+export declare const isLinux: boolean;
+export declare const isFreeBSD: boolean;
+export declare const isIBMi: boolean;
+export 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";
+};
+export type EventName = (typeof EVENTS)[keyof typeof EVENTS];
+export type FsWatchContainer = {
+    listeners: (path: string) => void | Set<any>;
+    errHandlers: (err: unknown) => void | Set<any>;
+    rawEmitters: (ev: WatchEventType, path: string, opts: unknown) => void | Set<any>;
+    watcher: NativeFsWatcher;
+    watcherUnusable?: boolean;
+};
+export interface WatchHandlers {
+    listener: (path: string) => void;
+    errHandler: (err: unknown) => void;
+    rawEmitter: (ev: WatchEventType, path: string, opts: unknown) => void;
+}
+/**
+ * @mixin
+ */
+export 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>;
+}

package/compiled/chokidar/index.d.ts

@@ -1,176 +1,9 @@
-import { WatchEventType, Stats as Stats$1 } from 'fs';
-import { EventEmitter } from 'events';
-import { Dirent, Stats } 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$1, 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, 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$1, initialAdd: boolean, depth: number, target: string, 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 = {
+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 = {
     stabilityThreshold: number;
     pollInterval: number;
 };
@@ -187,29 +20,29 @@ type BasicOpts = {
     ignorePermissionErrors: boolean;
     atomic: boolean | number;
 };
-type Throttler = {
+export type Throttler = {
     timeoutObject: NodeJS.Timeout;
     clear: () => void;
     count: number;
 };
-type ChokidarOptions = Partial<BasicOpts & {
+export type ChokidarOptions = Partial<BasicOpts & {
     ignored: Matcher | Matcher[];
     awaitWriteFinish: boolean | Partial<AWF>;
 }>;
-type FSWInstanceOptions = BasicOpts & {
+export type FSWInstanceOptions = BasicOpts & {
     ignored: Matcher[];
     awaitWriteFinish: false | AWF;
 };
-type ThrottleType = 'readdir' | 'watch' | 'add' | 'remove' | 'change';
-type EmitArgs = [path: Path, stats?: Stats$1];
-type EmitErrorArgs = [error: Error, stats?: Stats$1];
-type EmitArgsWithName = [event: EventName, ...EmitArgs];
-type MatchFunction = (val: string, stats?: Stats$1) => boolean;
-interface MatcherObject {
+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 {
     path: string;
     recursive?: boolean;
 }
-type Matcher = string | RegExp | MatchFunction | MatcherObject;
+export type Matcher = string | RegExp | MatchFunction | MatcherObject;
 /**
  * Directory entry.
  */
@@ -224,7 +57,7 @@ declare class DirEntry {
     getChildren(): string[];
     dispose(): void;
 }
-declare class WatchHelper {
+export declare class WatchHelper {
     fsw: FSWatcher;
     path: string;
     watchPath: string;
@@ -237,15 +70,17 @@ declare class WatchHelper {
     filterPath(entry: EntryInfo): boolean;
     filterDir(entry: EntryInfo): boolean;
 }
-interface FSWatcherKnownEventMap {
-    [EVENTS.READY]: [];
-    [EVENTS.RAW]: Parameters<WatchHandlers['rawEmitter']>;
-    [EVENTS.ERROR]: Parameters<WatchHandlers['errHandler']>;
-    [EVENTS.ALL]: [event: EventName, ...EmitArgs];
+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;
 }
-type FSWatcherEventMap = FSWatcherKnownEventMap & {
-    [k in Exclude<EventName, keyof FSWatcherKnownEventMap>]: EmitArgs;
-};
 /**
  * Watches files & directories for changes. Emitted events:
  * `add`, `addDir`, `change`, `unlink`, `unlinkDir`, `all`, `error`
@@ -254,7 +89,7 @@ type FSWatcherEventMap = FSWatcherKnownEventMap & {
  *       .add(directories)
  *       .on('add', path => log('File', path, 'was added'))
  */
-declare class FSWatcher extends EventEmitter<FSWatcherEventMap> {
+export declare class FSWatcher extends EventEmitter<FSWatcherEventMap> {
     closed: boolean;
     options: FSWInstanceOptions;
     _closers: Map<string, Array<any>>;
@@ -303,7 +138,7 @@ declare class FSWatcher extends EventEmitter<FSWatcherEventMap> {
      * @param stats arguments to be passed with event
      * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
      */
-    _emit(event: EventName, path: Path, stats?: Stats$1): Promise<this | undefined>;
+    _emit(event: EventName, path: Path, stats?: Stats): Promise<this | undefined>;
     /**
      * Common handler for errors
      * @returns The error if defined, otherwise the value of the FSWatcher instance's `closed` flag
@@ -326,12 +161,12 @@ declare class FSWatcher extends EventEmitter<FSWatcherEventMap> {
      * @param event
      * @param awfEmit Callback to be called when ready for event to be emitted.
      */
-    _awaitWriteFinish(path: Path, threshold: number, event: EventName, awfEmit: (err?: Error, stat?: Stats$1) => void): void;
+    _awaitWriteFinish(path: Path, threshold: number, event: EventName, awfEmit: (err?: Error, stat?: Stats) => void): void;
     /**
      * Determines whether user has asked to ignore this path.
      */
-    _isIgnored(path: Path, stats?: Stats$1): boolean;
-    _isntIgnored(path: Path, stat?: Stats$1): boolean;
+    _isIgnored(path: Path, stats?: Stats): boolean;
+    _isntIgnored(path: Path, stat?: Stats): boolean;
     /**
      * Provides a set of common helpers and properties relating to symlink handling.
      * @param path file or directory pattern being watched
@@ -345,7 +180,7 @@ declare class FSWatcher extends EventEmitter<FSWatcherEventMap> {
     /**
      * Check for read permissions: https://stackoverflow.com/a/11781404/1358405
      */
-    _hasReadPermissions(stats: Stats$1): boolean;
+    _hasReadPermissions(stats: Stats): boolean;
     /**
      * Handles emitting unlink events for
      * files and directories, and via recursion, for
@@ -374,11 +209,9 @@ 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') })
  */
-declare function watch(paths: string | string[], options?: ChokidarOptions): FSWatcher;
+export declare function watch(paths: string | string[], options?: ChokidarOptions): FSWatcher;
 declare const _default: {
     watch: typeof watch;
     FSWatcher: typeof FSWatcher;
 };
-
-export { FSWatcher, WatchHelper, _default as default, watch };
-export type { ChokidarOptions, EmitArgs, EmitArgsWithName, EmitErrorArgs, FSWInstanceOptions, FSWatcherEventMap, FSWatcherKnownEventMap, MatchFunction, Matcher, MatcherObject, ThrottleType, Throttler };
+export default _default;

package/compiled/chokidar/package.json

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