@lynx-js/rspeedy 0.8.2

package/lib/cli/commands.js

@@ -0,0 +1,45 @@
+import { version } from '../version.js';
+function applyCommonOptions(command) {
+    command
+        .option('-c --config <config>', 'specify the configuration file, can be a relative or absolute path');
+}
+export function apply(program) {
+    // TODO(cli): support custom cwd
+    const cwd = process.cwd();
+    program
+        .name('rspeedy')
+        .usage('<command> [options]')
+        .version(version)
+        .option('--unmanaged', 'Force to use the unmanaged version of Rspeedy, instead of the locally installed.')
+        .showHelpAfterError(true)
+        .showSuggestionAfterError(true)
+        .exitOverride(); // Avoid calling `process.exit` by commander
+    const buildCommand = program.command('build');
+    buildCommand
+        .description('Build the project in production mode')
+        .action((buildOptions) => import('./build.js').then(({ build }) => build.call(buildCommand, cwd, buildOptions)));
+    const devCommand = program.command('dev');
+    devCommand
+        .description('Run the dev server and watch for source file changes while serving.')
+        .action((devOptions) => import('./dev.js').then(({ dev }) => dev.call(devCommand, cwd, devOptions)));
+    const inspectCommand = program.command('inspect');
+    inspectCommand
+        .description('View the Rsbuild config and Rspack config of the project.')
+        .option('--mode <mode>', 'specify the mode of Rsbuild', 'development')
+        .option('--output <output>', 'specify inspect content output path')
+        .option('--verbose', 'show full function definitions in output')
+        .action((inspectOptions) => import('./inspect.js').then(({ inspect }) => inspect.call(inspectCommand, cwd, inspectOptions)));
+    const previewCommand = program.command('preview');
+    previewCommand
+        .description('Preview the production build outputs locally.')
+        .action((previewOptions) => import('./preview.js').then(({ preview }) => preview.call(previewCommand, cwd, previewOptions)));
+    const commonCommands = [
+        devCommand,
+        buildCommand,
+        inspectCommand,
+        previewCommand,
+    ];
+    commonCommands.forEach((command) => applyCommonOptions(command));
+    return program;
+}
+//# sourceMappingURL=commands.js.map

package/lib/cli/dev.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from 'commander';
+import type { CommonOptions } from './commands.js';
+export type DevOptions = CommonOptions;
+export declare function dev(this: Command, cwd: string, devOptions: DevOptions): Promise<void>;

package/lib/cli/dev.js

@@ -0,0 +1,75 @@
+// Copyright 2024 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+import path from 'node:path';
+import { logger } from '@rsbuild/core';
+import color from 'picocolors';
+import { loadConfig, resolveConfigPath } from '../config/loadConfig.js';
+import { createRspeedy } from '../create-rspeedy.js';
+import { exit } from './exit.js';
+export async function dev(cwd, devOptions) {
+    let onBeforeRestart = [];
+    try {
+        const configPath = resolveConfigPath(cwd, devOptions.config);
+        const { content: rspeedyConfig } = await loadConfig({
+            cwd,
+            configPath,
+        });
+        const watchedFiles = [configPath];
+        if (Array.isArray(rspeedyConfig.dev?.watchFiles)) {
+            watchedFiles.push(...rspeedyConfig.dev.watchFiles
+                .filter(item => item.type === 'reload-server')
+                .flatMap(item => item.paths));
+        }
+        else if (rspeedyConfig.dev?.watchFiles?.type === 'reload-server') {
+            const { paths } = rspeedyConfig.dev.watchFiles;
+            watchedFiles.push(...Array.isArray(paths) ? paths : [paths]);
+        }
+        await watchFiles(watchedFiles.map(filePath => path.isAbsolute(filePath) ? filePath : path.join(cwd, filePath)), async (filename) => {
+            logger.info(`Restart because ${color.yellow(filename)} is changed.\n`);
+            const cleanup = onBeforeRestart.map(f => f());
+            onBeforeRestart = [];
+            await Promise.all(cleanup);
+            await dev.call(this, cwd, devOptions);
+        });
+        const rspeedy = await createRspeedy({ cwd, rspeedyConfig });
+        const server = await rspeedy.createDevServer();
+        const { server: { close } } = await server.listen();
+        onBeforeRestart.push(close);
+    }
+    catch (error) {
+        logger.error(error);
+        exit(1);
+    }
+}
+async function watchFiles(files, callback) {
+    const chokidar = await import('chokidar');
+    const watcher = chokidar.default.watch(files, {
+        // do not trigger add for initial files
+        ignoreInitial: true,
+        // If watching fails due to read permissions, the errors will be suppressed silently.
+        ignorePermissionErrors: true,
+    });
+    const cb = debounce((event, filePath) => {
+        const startTime = Date.now();
+        void watcher.close().then(() => callback(filePath, startTime, event));
+    }, 
+    // set 300ms debounce to avoid restart frequently
+    300);
+    watcher.once('add', cb.bind(null, 'add'));
+    watcher.once('change', cb.bind(null, 'change'));
+    watcher.once('unlink', cb.bind(null, 'unlink'));
+}
+// biome-ignore lint/suspicious/noExplicitAny: Make TS happy
+function debounce(func, wait) {
+    let timeoutId = null;
+    return (...args) => {
+        if (timeoutId !== null) {
+            clearTimeout(timeoutId);
+        }
+        timeoutId = setTimeout(() => {
+            func(...args);
+        }, wait);
+    };
+}
+//# sourceMappingURL=dev.js.map

package/lib/cli/exit.d.ts

@@ -0,0 +1 @@
+export declare const exit: (signal?: number | undefined) => void;

package/lib/cli/exit.js

@@ -0,0 +1,51 @@
+// Copyright 2024 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+import { logger } from '@rsbuild/core';
+import { asyncExitHook, gracefulExit } from 'exit-hook';
+import color from 'picocolors';
+import { debug } from '../debug.js';
+const start = Date.now();
+const exitPromises = [];
+const unsubscribe = asyncExitHook(onExit, { wait: 1000 });
+// eslint-disable-next-line @typescript-eslint/no-misused-promises
+process.on('unhandledRejection', async (reason) => {
+    logger.error('Unhandled Rejection with reason:', reason instanceof Error ? reason : new Error(JSON.stringify(reason)));
+    // Here we do not directly use `gracefulExit` since it will wait until
+    // the compilation finished.
+    unsubscribe();
+    await onExit(1);
+    // eslint-disable-next-line n/no-process-exit
+    process.exit(1);
+});
+let interrupted = false;
+process.on('SIGINT', () => {
+    if (interrupted) {
+        logger.info(`Force exiting Rspeedy.`);
+        // The `exit` is not complete, yet.
+        // But the `Ctrl + C` has been pressed again, we make a force exit here.
+        // eslint-disable-next-line n/no-process-exit
+        return process.exit(/** 128 + 2(kill) */ 130);
+    }
+    interrupted = true;
+    logger.info(`Gracefully shutting down. Please wait... (Press ${color.cyan('Ctrl+C')} again to force exit)`);
+    // Graceful exit with code 130
+    // see: https://nodejs.org/docs/latest/api/process.html#signal-events
+    exit(/** 128 + 2(kill) */ 130);
+});
+let previousSignal = null;
+export const exit = (signal = 0) => {
+    if (previousSignal !== null) {
+        debug(`graceful exit called multiple times, current: ${signal}, previous: ${previousSignal}`);
+    }
+    previousSignal = signal;
+    debug(`graceful exit process with signal: ${signal}`);
+    gracefulExit(signal);
+};
+async function onExit(signal) {
+    const duration = Date.now() - start;
+    debug(`exit hook fired with signal: ${signal}, duration: ${duration}`);
+    debug(`awaiting exit promises(length: ${exitPromises.length})...`);
+    await Promise.allSettled(exitPromises);
+}
+//# sourceMappingURL=exit.js.map

package/lib/cli/inspect.d.ts

@@ -0,0 +1,8 @@
+import type { Command } from 'commander';
+import type { CommonOptions } from './commands.js';
+export interface InspectOptions extends CommonOptions {
+    mode?: 'production' | 'development' | undefined;
+    verbose?: boolean | undefined;
+    output?: string | undefined;
+}
+export declare function inspect(this: Command, cwd: string, inspectOptions: InspectOptions): Promise<void>;

package/lib/cli/inspect.js

@@ -0,0 +1,30 @@
+// Copyright 2024 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+import { logger } from '@rsbuild/core';
+import { exit } from './exit.js';
+import { loadConfig } from '../config/loadConfig.js';
+import { createRspeedy } from '../create-rspeedy.js';
+export async function inspect(cwd, inspectOptions) {
+    try {
+        const { content: rspeedyConfig } = await loadConfig({
+            cwd,
+            configPath: inspectOptions.config,
+        });
+        const rspeedy = await createRspeedy({ cwd, rspeedyConfig });
+        await rspeedy.inspectConfig({
+            mode: inspectOptions.mode
+                ?? process.env['NODE_ENV']
+                ?? 'development',
+            verbose: inspectOptions.verbose ?? false,
+            outputPath: inspectOptions.output,
+            writeToDisk: true,
+        });
+        return exit();
+    }
+    catch (error) {
+        logger.error(error);
+        logger.error();
+    }
+}
+//# sourceMappingURL=inspect.js.map

package/lib/cli/main.d.ts

@@ -0,0 +1 @@
+export declare function main(argv: string[]): Promise<void>;

package/lib/cli/main.js

@@ -0,0 +1,39 @@
+// Copyright 2024 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+import { logger } from '@rsbuild/core';
+import { exit } from './exit.js';
+import { debug } from '../debug.js';
+function initNodeEnv(argv) {
+    if (!process.env['NODE_ENV']) {
+        const NODE_ENV = (argv.includes('dev') || argv.includes('preview'))
+            ? 'development'
+            : 'production';
+        process.env['NODE_ENV'] = NODE_ENV;
+        debug(`No NODE_ENV found, set to ${NODE_ENV}`);
+    }
+}
+export async function main(argv) {
+    initNodeEnv(argv);
+    // If not called through a package manager,
+    // output a blank line to keep the greet log nice.
+    const { npm_execpath } = process.env;
+    if (!npm_execpath || npm_execpath.includes('npm-cli.js')
+        || npm_execpath.includes('npx-cli.js')) {
+        // biome-ignore lint/suspicious/noConsoleLog: <explanation>
+        console.log();
+    }
+    const { version, rsbuildVersion, rspackVersion } = await import('../version.js');
+    logger.greet(`  Rspeedy v${version} (Rsbuild v${rsbuildVersion}, Rspack v${rspackVersion})\n`);
+    try {
+        const [{ Command }, { apply },] = await Promise.all([
+            import('commander'),
+            import('./commands.js'),
+        ]);
+        apply(new Command('rspeedy')).parse(argv);
+    }
+    catch {
+        return exit(1);
+    }
+}
+//# sourceMappingURL=main.js.map

package/lib/cli/preview.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from 'commander';
+import type { CommonOptions } from './commands.js';
+export type PreviewOptions = CommonOptions;
+export declare function preview(this: Command, cwd: string, options: PreviewOptions): Promise<void>;

package/lib/cli/preview.js

@@ -0,0 +1,31 @@
+// Copyright 2024 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+import fs from 'node:fs';
+import { logger } from '@rsbuild/core';
+import color from 'picocolors';
+import { exit } from './exit.js';
+import { loadConfig } from '../config/loadConfig.js';
+import { createRspeedy } from '../create-rspeedy.js';
+export async function preview(cwd, options) {
+    try {
+        const { content: rspeedyConfig } = await loadConfig({
+            cwd,
+            configPath: options.config,
+        });
+        const rspeedy = await createRspeedy({ cwd, rspeedyConfig });
+        await rspeedy.initConfigs();
+        const { distPath } = rspeedy.context;
+        if (!fs.existsSync(distPath)) {
+            throw new Error(`The output directory ${color.yellow(distPath)} does not exist, please build the project before previewing.`);
+        }
+        await rspeedy.preview();
+    }
+    catch (error) {
+        logger.error('Failed to start preview server.');
+        logger.error(error);
+        exit(1);
+        return;
+    }
+}
+//# sourceMappingURL=preview.js.map

package/lib/cli/start.d.ts

@@ -0,0 +1,6 @@
+/**
+ * When rspeedy is invoked via the shell path, we examine the project's package.json dependencies and try to load
+ * the locally installed version of rspeedy. This avoids accidentally building using the wrong version of rspeedy.
+ * Use "rspeedy --unmanaged" to bypass this feature.
+ */
+export declare function tryStartLocalRspeedy(root?: string): false | Promise<void>;

package/lib/cli/start.js

@@ -0,0 +1,88 @@
+// Copyright 2024 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { logger } from '@rsbuild/core';
+import { debug } from '../debug.js';
+var Constants;
+(function (Constants) {
+    Constants["rspeedyPackageName"] = "@lynx-js/rspeedy";
+    Constants["unmanagedParameterLongName"] = "--unmanaged";
+})(Constants || (Constants = {}));
+// Excerpted from PackageJsonLookup.tryGetPackageFolderFor()
+function tryGetPackageFolderFor(resolvedFileOrFolderPath) {
+    // Is resolvedFileOrFolderPath itself a folder with a package.json file?  If so, return it.
+    if (fs.existsSync(path.join(resolvedFileOrFolderPath, 'package.json'))) {
+        return resolvedFileOrFolderPath;
+    }
+    // Otherwise go up one level
+    const parentFolder = path.dirname(resolvedFileOrFolderPath);
+    if (!parentFolder || parentFolder === resolvedFileOrFolderPath) {
+        // We reached the root directory without finding a package.json file,
+        // so cache the negative result
+        return undefined; // no match
+    }
+    // Recurse upwards
+    return tryGetPackageFolderFor(parentFolder);
+}
+/**
+ * When rspeedy is invoked via the shell path, we examine the project's package.json dependencies and try to load
+ * the locally installed version of rspeedy. This avoids accidentally building using the wrong version of rspeedy.
+ * Use "rspeedy --unmanaged" to bypass this feature.
+ */
+export function tryStartLocalRspeedy(root = process.cwd()) {
+    if (process.argv.includes(Constants.unmanagedParameterLongName)) {
+        logger.info(`Bypassing the Rspeedy version selector because ${JSON.stringify(Constants.unmanagedParameterLongName)} was specified.`);
+        logger.info();
+        return false;
+    }
+    // The unmanaged flag could be undiscoverable if it's not in their locally installed version
+    debug(`Searching for a locally installed version of Rspeedy. Use the ${JSON.stringify(Constants.unmanagedParameterLongName)} flag if you want to avoid this.`);
+    // Find the package.json file that governs the current folder location
+    const projectFolder = tryGetPackageFolderFor(root);
+    if (projectFolder) {
+        debug(`found project at ${projectFolder}`);
+        let rspeedyEntryPoint;
+        let packageJson;
+        try {
+            const packageJsonPath = path.join(projectFolder, 'package.json');
+            const packageJsonContent = fs.readFileSync(packageJsonPath).toString();
+            try {
+                packageJson = JSON.parse(packageJsonContent);
+            }
+            catch (error) {
+                throw new Error(`Error parsing ${packageJsonPath}:${error.message}`);
+            }
+            // Does package.json have a dependency on Rspeedy?
+            if (!(packageJson.dependencies?.[Constants.rspeedyPackageName])
+                && !(packageJson.devDependencies?.[Constants.rspeedyPackageName])) {
+                // No explicit dependency on rspeedy
+                debug('The project does not have a dependency on Rspeedy');
+                return false;
+            }
+            // To avoid a loading the "resolve" NPM package, let's assume that the rspeedy dependency must be
+            // installed as "<projectFolder>/node_modules/@lynx-js/rspeedy".
+            const rspeedyFolder = path.join(projectFolder, 'node_modules', ...Constants.rspeedyPackageName.split('/'));
+            rspeedyEntryPoint = path.join(rspeedyFolder, 'lib', 'cli', 'main.js');
+            if (!fs.existsSync(rspeedyEntryPoint)) {
+                debug(`Unable to find rspeedy entry point: ${rspeedyEntryPoint}, using the unmanaged version.`);
+                return false;
+            }
+        }
+        catch (error) {
+            throw new Error(`Error probing for local rspeedy version: ${error.message}`);
+        }
+        debug(`found rspeedy entry point at ${rspeedyEntryPoint}`);
+        // We found and successfully invoked the local rspeedy
+        // Note that we are using `pathToFileURL` since absolute paths must be valid file:// URLs on Windows.
+        return import(pathToFileURL(rspeedyEntryPoint).toString()).then(({ main }) => main(process.argv));
+    }
+    debug(`no project folder found from ${process.cwd()}`);
+    // We couldn't find the package folder
+    return false;
+}
+//# sourceMappingURL=start.js.map

package/lib/config/defaults.d.ts

@@ -0,0 +1,2 @@
+import type { Config } from './index.js';
+export declare function applyDefaultRspeedyConfig(config: Config): Config;

package/lib/config/defaults.js

@@ -0,0 +1,32 @@
+// Copyright 2024 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+import { mergeRsbuildConfig } from '@rsbuild/core';
+export function applyDefaultRspeedyConfig(config) {
+    const ret = mergeRsbuildConfig(config, {
+        output: {
+            // We are applying the default filename to the config
+            // since some plugin(e.g.: `@lynx-js/qrcode-rsbuild-plugin`) will read
+            // from the `output.filename.bundle` field.
+            filename: getFilename(config.output?.filename),
+        },
+    });
+    return ret;
+}
+const DEFAULT_FILENAME = '[name].[platform].bundle';
+function getFilename(filename) {
+    if (typeof filename === 'string') {
+        return {
+            bundle: filename,
+            template: filename,
+        };
+    }
+    const finalFilename = filename?.bundle
+        ?? filename?.template
+        ?? DEFAULT_FILENAME;
+    return {
+        bundle: finalFilename,
+        template: finalFilename,
+    };
+}
+//# sourceMappingURL=defaults.js.map

package/lib/config/defineConfig.d.ts

@@ -0,0 +1,22 @@
+import type { Config } from './index.js';
+/**
+ * The `defineConfig` method is a helper function used to get TypeScript intellisense.
+ *
+ * @param config - The config of Rspeedy.
+ * @returns - The identical config as the input config.
+ *
+ * @example
+ *
+ * Use `defineConfig` in `lynx.config.ts`:
+ *
+ * ```ts
+ * //@ts-check
+ * import { defineConfig } from '@lynx-js/rspeedy'
+ * export default defineConfig({
+ *   // autocompletion works here!
+ * })
+ * ```
+ *
+ * @public
+ */
+export declare function defineConfig(config: Config): Config;

package/lib/config/defineConfig.js

@@ -0,0 +1,24 @@
+/**
+ * The `defineConfig` method is a helper function used to get TypeScript intellisense.
+ *
+ * @param config - The config of Rspeedy.
+ * @returns - The identical config as the input config.
+ *
+ * @example
+ *
+ * Use `defineConfig` in `lynx.config.ts`:
+ *
+ * ```ts
+ * //@ts-check
+ * import { defineConfig } from '@lynx-js/rspeedy'
+ * export default defineConfig({
+ *   // autocompletion works here!
+ * })
+ * ```
+ *
+ * @public
+ */
+export function defineConfig(config) {
+    return config;
+}
+//# sourceMappingURL=defineConfig.js.map

package/lib/config/dev/client.d.ts

@@ -0,0 +1,15 @@
+/**
+ * {@inheritdoc Dev.client}
+ *
+ * @public
+ */
+export interface Client {
+    /**
+     * The path to websocket.
+     *
+     * @remarks
+     *
+     * Defaults to `require.resolve('@lynx-js/websocket')`
+     */
+    websocketTransport?: string | undefined;
+}

package/lib/config/dev/client.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=client.js.map

package/lib/config/dev/index.d.ts

@@ -0,0 +1,133 @@
+import type { WatchFiles } from '@rsbuild/core';
+import type { Client } from './client.js';
+/**
+ * {@inheritdoc Config.dev}
+ * @public
+ */
+export interface Dev {
+    /**
+     * The {@link Dev.assetPrefix} is used to set the URL prefix for static assets during development.
+     * @remarks
+     *
+     * The functionality of {@link Dev.assetPrefix} is basically the same as the {@link https://www.rspack.dev/config/output#outputpublicpath | output.publicPath}
+     * config in Rspack. With the following differences:
+     *
+     * - `dev.assetPrefix` only takes effect during development.
+     *
+     * - `dev.assetPrefix` automatically appends a trailing `/` by default.
+     *
+     * - The value of `dev.assetPrefix` is written to the `process.env.ASSET_PREFIX` environment variable.
+     *
+     * @example
+     *
+     * If `dev.assetPrefix` is set to true, the URL prefix will be `http://<host>:<port>/`:
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     * export default defineConfig({
+     *   dev: {
+     *     assetPrefix: true,
+     *   },
+     * })
+     * ```
+     *
+     * @example
+     *
+     * If `dev.assetPrefix` is set to a string, the value will be used as a prefix and automatically appended to the static resource URL.
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     * export default defineConfig({
+     *   dev: {
+     *     assetPrefix: 'https://example.com/assets/',
+     *   },
+     * })
+     * ```
+     *
+     * @example
+     *
+     * The port number that Rspeedy server listens on may change. For example, if the port is in use, Rspeedy will automatically increment the port number until it finds an available port.
+     *
+     * To avoid `dev.assetPrefix` becoming invalid due to port changes, you can use one of the following methods:
+     *
+     * - Enable `server.strictPort`.
+     *
+     * - Use the `<port>` placeholder to refer to the current port number. Rspeedy will replace the placeholder with the actual port number it is listening on.
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     * export default defineConfig({
+     *   dev: {
+     *     assetPrefix: 'https://example.com:<port>/assets/',
+     *   },
+     * })
+     * ```
+     */
+    assetPrefix?: string | boolean | undefined;
+    /**
+     * Configuration of the development client.
+     */
+    client?: Client | undefined;
+    /**
+     * Watch specified files and directories for changes. When a file change is detected, it can trigger a page reload or restart the dev server.
+     *
+     * @example
+     *
+     * - Specify the files and directories watched for changes.
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * export default defineConfig({
+     *   dev: {
+     *     watchFiles: {
+     *       paths: ['src/**', 'public/**'],
+     *     },
+     *   },
+     * })
+     * ```
+     *
+     * @example
+     *
+     * - Use {@link https://github.com/paulmillr/chokidar#api | chokidar} options for watching.
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * export default defineConfig({
+     *   dev: {
+     *     watchFiles: {
+     *       paths: ['src/**', 'public/**'],
+     *       options: { usePolling: false },
+     *     },
+     *   },
+     * })
+     * ```
+     */
+    watchFiles?: WatchFiles | WatchFiles[] | undefined;
+    /**
+     * Used to control whether the build artifacts of the development environment are written to the disk.
+     *
+     * @remarks
+     *
+     * This is bypassed to {@link https://github.com/webpack/webpack-dev-middleware?tab=readme-ov-file#writetodisk | `webpack-dev-middleware`}.
+     *
+     * Setting `writeToDisk: true` won't change the behavior of the `webpack-dev-middleware`, and bundle files accessed through the browser will still be served from memory.
+     *
+     * This option also accepts a `Function` value, which can be used to filter which files are written to disk.
+     *
+     * The function follows the same premise as `Array#filter` in which a return value of `false` will not write the file, and a return value of `true` will write the file to disk.
+     *
+     * @example
+     * ```js
+     * // lynx.config.ts
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     * export default defineConfig({
+     *   dev: {
+     *     writeToDisk: (filePath) => /superman\.css$/.test(filePath),
+     *   },
+     * })
+     * ```
+     */
+    writeToDisk?: boolean | ((filename: string) => boolean) | undefined;
+}

package/lib/config/dev/index.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.js.map