@rspack/dev-middleware 0.2.12 → 2.0.0-beta.0

package/types/utils/compatibleAPI.d.ts

@@ -0,0 +1,261 @@
+export type IncomingMessage = import("../index").IncomingMessage;
+export type ServerResponse = import("../index").ServerResponse;
+export type OutputFileSystem = import("../index").OutputFileSystem;
+export type EXPECTED_ANY = import("../index").EXPECTED_ANY;
+export type ExpectedIncomingMessage = {
+  /**
+   * get header extra method
+   */
+  getHeader?: ((name: string) => string | string[] | undefined) | undefined;
+  /**
+   * get method extra method
+   */
+  getMethod?: (() => string | undefined) | undefined;
+  /**
+   * get URL extra method
+   */
+  getURL?: (() => string | undefined) | undefined;
+  /**
+   * an extra option for `fastify` (and `@fastify/express`) to get original URL
+   */
+  originalUrl?: string | undefined;
+};
+export type ExpectedServerResponse = {
+  /**
+   * set status code
+   */
+  setStatusCode?: ((status: number) => void) | undefined;
+  /**
+   * get status code
+   */
+  getStatusCode?: (() => number) | undefined;
+  /**
+   * get header
+   */
+  getHeader: (name: string) => string | string[] | undefined | number;
+  /**
+   * set header
+   */
+  setHeader?:
+    | ((
+        name: string,
+        value: number | string | Readonly<string[]>,
+      ) => ExpectedServerResponse)
+    | undefined;
+  /**
+   * remove header
+   */
+  removeHeader?: ((name: string) => void) | undefined;
+  /**
+   * send
+   */
+  send?: ((data: string | Buffer) => void) | undefined;
+  /**
+   * finish
+   */
+  finish?: ((data?: string | Buffer) => void) | undefined;
+  /**
+   * get response header
+   */
+  getResponseHeaders?: (() => string[]) | undefined;
+  /**
+   * get headers sent
+   */
+  getHeadersSent?: (() => boolean) | undefined;
+  /**
+   * stream
+   */
+  stream?: ((data: EXPECTED_ANY) => void) | undefined;
+  /**
+   * get outgoing
+   */
+  getOutgoing?: (() => EXPECTED_ANY) | undefined;
+  /**
+   * set state
+   */
+  setState?: ((name: string, value: EXPECTED_ANY) => void) | undefined;
+};
+/**
+ * @param {string} filename filename
+ * @param {OutputFileSystem} outputFileSystem output file system
+ * @param {number} start start
+ * @param {number} end end
+ * @returns {{ bufferOrStream: (Buffer | import("fs").ReadStream), byteLength: number }} result with buffer or stream and byte length
+ */
+export function createReadStreamOrReadFileSync(
+  filename: string,
+  outputFileSystem: OutputFileSystem,
+  start: number,
+  end: number,
+): {
+  bufferOrStream: Buffer | import("fs").ReadStream;
+  byteLength: number;
+};
+/**
+ * @template {ServerResponse & ExpectedServerResponse} Response
+ * @param {Response} res res
+ * @param {(string | Buffer)=} data data
+ */
+export function finish<
+  Response extends ServerResponse & ExpectedServerResponse,
+>(res: Response, data?: (string | Buffer) | undefined): void;
+/**
+ * @template {ServerResponse & ExpectedServerResponse} Response
+ * @param {Response} res res
+ * @returns {boolean} true when headers were sent, otherwise false
+ */
+export function getHeadersSent<
+  Response extends ServerResponse & ExpectedServerResponse,
+>(res: Response): boolean;
+/**
+ * @template {ServerResponse & ExpectedServerResponse} Response
+ * @param {Response} res res
+ * @returns {Response} res res
+ */
+export function getOutgoing<
+  Response extends ServerResponse & ExpectedServerResponse,
+>(res: Response): Response;
+/** @typedef {import("../index").IncomingMessage} IncomingMessage */
+/** @typedef {import("../index").ServerResponse} ServerResponse */
+/** @typedef {import("../index").OutputFileSystem} OutputFileSystem */
+/** @typedef {import("../index").EXPECTED_ANY} EXPECTED_ANY */
+/**
+ * @typedef {object} ExpectedIncomingMessage
+ * @property {((name: string) => string | string[] | undefined)=} getHeader get header extra method
+ * @property {(() => string | undefined)=} getMethod get method extra method
+ * @property {(() => string | undefined)=} getURL get URL extra method
+ * @property {string=} originalUrl an extra option for `fastify` (and `@fastify/express`) to get original URL
+ */
+/**
+ * @typedef {object} ExpectedServerResponse
+ * @property {((status: number) => void)=} setStatusCode set status code
+ * @property {(() => number)=} getStatusCode get status code
+ * @property {((name: string) => string | string[] | undefined | number)} getHeader get header
+ * @property {((name: string, value: number | string | Readonly<string[]>) => ExpectedServerResponse)=} setHeader set header
+ * @property {((name: string) => void)=} removeHeader remove header
+ * @property {((data: string | Buffer) => void)=} send send
+ * @property {((data?: string | Buffer) => void)=} finish finish
+ * @property {(() => string[])=} getResponseHeaders get response header
+ * @property {(() => boolean)=} getHeadersSent get headers sent
+ * @property {((data: EXPECTED_ANY) => void)=} stream stream
+ * @property {(() => EXPECTED_ANY)=} getOutgoing get outgoing
+ * @property {((name: string, value: EXPECTED_ANY) => void)=} setState set state
+ */
+/**
+ * @template {IncomingMessage & ExpectedIncomingMessage} Request
+ * @param {Request} req req
+ * @param {string} name name
+ * @returns {string | string[] | undefined} request header
+ */
+export function getRequestHeader<
+  Request extends IncomingMessage & ExpectedIncomingMessage,
+>(req: Request, name: string): string | string[] | undefined;
+/**
+ * @template {IncomingMessage & ExpectedIncomingMessage} Request
+ * @param {Request} req req
+ * @returns {string | undefined} request method
+ */
+export function getRequestMethod<
+  Request extends IncomingMessage & ExpectedIncomingMessage,
+>(req: Request): string | undefined;
+/**
+ * @template {IncomingMessage & ExpectedIncomingMessage} Request
+ * @param {Request} req req
+ * @returns {string | undefined} request URL
+ */
+export function getRequestURL<
+  Request extends IncomingMessage & ExpectedIncomingMessage,
+>(req: Request): string | undefined;
+/**
+ * @template {ServerResponse & ExpectedServerResponse} Response
+ * @param {Response} res res
+ * @param {string} name name
+ * @returns {string | string[] | undefined | number} header
+ */
+export function getResponseHeader<
+  Response extends ServerResponse & ExpectedServerResponse,
+>(res: Response, name: string): string | string[] | undefined | number;
+/**
+ * @template {ServerResponse & ExpectedServerResponse} Response
+ * @param {Response} res res
+ * @returns {string[]} header names
+ */
+export function getResponseHeaders<
+  Response extends ServerResponse & ExpectedServerResponse,
+>(res: Response): string[];
+/**
+ * @template {ServerResponse & ExpectedServerResponse} Response
+ * @param {Response} res res
+ * @returns {number} status code
+ */
+export function getStatusCode<
+  Response extends ServerResponse & ExpectedServerResponse,
+>(res: Response): number;
+/**
+ * @template {ServerResponse & ExpectedServerResponse} Response
+ * @param {Response} res res
+ */
+export function initState<
+  Response extends ServerResponse & ExpectedServerResponse,
+>(res: Response): void;
+/**
+ * @template {ServerResponse & ExpectedServerResponse} Response
+ * @param {Response} res res
+ * @param {import("fs").ReadStream} bufferOrStream buffer or stream
+ */
+export function pipe<Response extends ServerResponse & ExpectedServerResponse>(
+  res: Response,
+  bufferOrStream: import("fs").ReadStream,
+): void;
+/**
+ * @template {ServerResponse & ExpectedServerResponse} Response
+ * @param {Response} res res
+ * @param {string} name name
+ * @returns {void}
+ */
+export function removeResponseHeader<
+  Response extends ServerResponse & ExpectedServerResponse,
+>(res: Response, name: string): void;
+/**
+ * @template {ServerResponse & ExpectedServerResponse} Response
+ * @param {Response} res res
+ * @param {string | Buffer} bufferOrString buffer or string
+ * @returns {void}
+ */
+export function send<Response extends ServerResponse & ExpectedServerResponse>(
+  res: Response,
+  bufferOrString: string | Buffer,
+): void;
+/**
+ * @template {ServerResponse & ExpectedServerResponse} Response
+ * @param {Response} res res
+ * @param {string} name name
+ * @param {number | string | Readonly<string[]>} value value
+ * @returns {Response} response
+ */
+export function setResponseHeader<
+  Response extends ServerResponse & ExpectedServerResponse,
+>(
+  res: Response,
+  name: string,
+  value: number | string | Readonly<string[]>,
+): Response;
+/**
+ * @template {ServerResponse & ExpectedServerResponse} Response
+ * @param {Response} res res
+ * @param {string} name name
+ * @param {EXPECTED_ANY} value state
+ * @returns {void}
+ */
+export function setState<
+  Response extends ServerResponse & ExpectedServerResponse,
+>(res: Response, name: string, value: EXPECTED_ANY): void;
+/**
+ * @template {ServerResponse & ExpectedServerResponse} Response
+ * @param {Response} res res
+ * @param {number} code code
+ * @returns {void}
+ */
+export function setStatusCode<
+  Response extends ServerResponse & ExpectedServerResponse,
+>(res: Response, code: number): void;

package/types/utils/escapeHtml.d.ts

@@ -0,0 +1,6 @@
+export default escapeHtml;
+/**
+ * @param {string} string raw HTML
+ * @returns {string} escaped HTML
+ */
+declare function escapeHtml(string: string): string;

package/types/utils/etag.d.ts

@@ -0,0 +1,12 @@
+export default etag;
+export type Stats = import("fs").Stats;
+export type ReadStream = import("fs").ReadStream;
+/**
+ * Create a simple ETag.
+ * @param {Buffer | ReadStream | Stats} entity entity
+ * @returns {Promise<{ hash: string, buffer?: Buffer }>} etag
+ */
+declare function etag(entity: Buffer | ReadStream | Stats): Promise<{
+  hash: string;
+  buffer?: Buffer;
+}>;

package/types/utils/getFilenameFromUrl.d.ts

@@ -0,0 +1,46 @@
+export default getFilenameFromUrl;
+export type IncomingMessage = import("../index.js").IncomingMessage;
+export type ServerResponse = import("../index.js").ServerResponse;
+export type Extra = {
+  /**
+   * stats
+   */
+  stats?: import("fs").Stats | undefined;
+  /**
+   * error code
+   */
+  errorCode?: number | undefined;
+  /**
+   * true when immutable, otherwise false
+   */
+  immutable?: boolean | undefined;
+};
+/**
+ * @typedef {object} Extra
+ * @property {import("fs").Stats=} stats stats
+ * @property {number=} errorCode error code
+ * @property {boolean=} immutable true when immutable, otherwise false
+ */
+/**
+ * decodeURIComponent.
+ *
+ * Allows V8 to only deoptimize this fn instead of all of send().
+ * @param {string} input
+ * @returns {string}
+ */
+/**
+ * @template {IncomingMessage} Request
+ * @template {ServerResponse} Response
+ * @param {import("../index.js").FilledContext<Request, Response>} context context
+ * @param {string} url url
+ * @param {Extra=} extra extra
+ * @returns {string | undefined} filename
+ */
+declare function getFilenameFromUrl<
+  Request extends IncomingMessage,
+  Response extends ServerResponse,
+>(
+  context: import("../index.js").FilledContext<Request, Response>,
+  url: string,
+  extra?: Extra | undefined,
+): string | undefined;

package/types/utils/getPaths.d.ts

@@ -0,0 +1,31 @@
+export default getPaths;
+export type Compiler = import("@rspack/core").Compiler;
+export type Stats = import("@rspack/core").Stats;
+export type MultiStats = import("@rspack/core").MultiStats;
+export type Asset = import("@rspack/core").Asset;
+export type DevServerOption = import("../index.js").DevServerOption;
+export type IncomingMessage = import("../index.js").IncomingMessage;
+export type ServerResponse = import("../index.js").ServerResponse;
+/** @typedef {import("@rspack/core").Compiler} Compiler */
+/** @typedef {import("@rspack/core").Stats} Stats */
+/** @typedef {import("@rspack/core").MultiStats} MultiStats */
+/** @typedef {import("@rspack/core").Asset} Asset */
+/** @typedef {import("../index.js").DevServerOption} DevServerOption */
+/** @typedef {import("../index.js").IncomingMessage} IncomingMessage */
+/** @typedef {import("../index.js").ServerResponse} ServerResponse */
+/**
+ * @template {IncomingMessage} Request
+ * @template {ServerResponse} Response
+ * @param {import("../index.js").FilledContext<Request, Response>} context context
+ * @returns {{ outputPath: string, publicPath: string, assetsInfo: Map<string, Asset["info"]> | undefined }[]} paths
+ */
+declare function getPaths<
+  Request extends IncomingMessage,
+  Response extends ServerResponse,
+>(
+  context: import("../index.js").FilledContext<Request, Response>,
+): {
+  outputPath: string;
+  publicPath: string;
+  assetsInfo: Map<string, Asset["info"]> | undefined;
+}[];

package/types/utils/memorize.d.ts

@@ -0,0 +1,33 @@
+export default memorize;
+export type FunctionReturning<T> = (...args: EXPECTED_ANY) => T;
+export type EXPECTED_ANY = import("../index").EXPECTED_ANY;
+/**
+ * @template T
+ * @typedef {(...args: EXPECTED_ANY) => T} FunctionReturning
+ */
+/**
+ * @template T
+ * @param {FunctionReturning<T>} fn memorized function
+ * @param {({ cache?: Map<string, { data: T }> } | undefined)=} cache cache
+ * @param {((value: T) => T)=} callback callback
+ * @returns {FunctionReturning<T>} new function
+ */
+declare function memorize<T>(
+  fn: FunctionReturning<T>,
+  {
+    cache,
+  }?:
+    | (
+        | {
+            cache?: Map<
+              string,
+              {
+                data: T;
+              }
+            >;
+          }
+        | undefined
+      )
+    | undefined,
+  callback?: ((value: T) => T) | undefined,
+): FunctionReturning<T>;

package/types/utils/parseTokenList.d.ts

@@ -0,0 +1,7 @@
+export default parseTokenList;
+/**
+ * Parse a HTTP token list.
+ * @param {string} str str
+ * @returns {string[]} tokens
+ */
+declare function parseTokenList(str: string): string[];

package/types/utils/ready.d.ts

@@ -0,0 +1,23 @@
+export default ready;
+export type IncomingMessage = import("../index.js").IncomingMessage;
+export type ServerResponse = import("../index.js").ServerResponse;
+export type Callback = import("../index.js").Callback;
+/** @typedef {import("../index.js").IncomingMessage} IncomingMessage */
+/** @typedef {import("../index.js").ServerResponse} ServerResponse */
+/** @typedef {import("../index.js").Callback} Callback */
+/**
+ * @template {IncomingMessage} Request
+ * @template {ServerResponse} Response
+ * @param {import("../index.js").FilledContext<Request, Response>} context context
+ * @param {Callback} callback callback
+ * @param {Request=} req req
+ * @returns {void}
+ */
+declare function ready<
+  Request extends IncomingMessage,
+  Response extends ServerResponse,
+>(
+  context: import("../index.js").FilledContext<Request, Response>,
+  callback: Callback,
+  req?: Request | undefined,
+): void;

package/types/utils/setupHooks.d.ts

@@ -0,0 +1,40 @@
+export default setupHooks;
+export type Configuration = import("@rspack/core").Configuration;
+export type Compiler = import("@rspack/core").Compiler;
+export type MultiCompiler = import("@rspack/core").MultiCompiler;
+export type Stats = import("@rspack/core").Stats;
+export type MultiStats = import("@rspack/core").MultiStats;
+export type IncomingMessage = import("../index.js").IncomingMessage;
+export type ServerResponse = import("../index.js").ServerResponse;
+export type StatsOptions = Configuration["stats"];
+export type MultiStatsOptions = {
+  children: Configuration["stats"][];
+};
+export type StatsObjectOptions = Exclude<
+  Configuration["stats"],
+  boolean | string | undefined
+>;
+/** @typedef {import("@rspack/core").Configuration} Configuration */
+/** @typedef {import("@rspack/core").Compiler} Compiler */
+/** @typedef {import("@rspack/core").MultiCompiler} MultiCompiler */
+/** @typedef {import("@rspack/core").Stats} Stats */
+/** @typedef {import("@rspack/core").MultiStats} MultiStats */
+/** @typedef {import("../index.js").IncomingMessage} IncomingMessage */
+/** @typedef {import("../index.js").ServerResponse} ServerResponse */
+/** @typedef {Configuration["stats"]} StatsOptions */
+/** @typedef {{ children: Configuration["stats"][] }} MultiStatsOptions */
+/** @typedef {Exclude<Configuration["stats"], boolean | string | undefined>} StatsObjectOptions */
+/**
+ * @template {IncomingMessage} Request
+ * @template {ServerResponse} Response
+ * @param {import("../index.js").WithOptional<import("../index.js").Context<Request, Response>, "watching" | "outputFileSystem">} context context
+ */
+declare function setupHooks<
+  Request extends IncomingMessage,
+  Response extends ServerResponse,
+>(
+  context: import("../index.js").WithOptional<
+    import("../index.js").Context<Request, Response>,
+    "watching" | "outputFileSystem"
+  >,
+): void;

package/types/utils/setupOutputFileSystem.d.ts

@@ -0,0 +1,23 @@
+export default setupOutputFileSystem;
+export type MultiCompiler = import("@rspack/core").MultiCompiler;
+export type DevServerOption = import("../index.js").DevServerOption;
+export type IncomingMessage = import("../index.js").IncomingMessage;
+export type ServerResponse = import("../index.js").ServerResponse;
+/** @typedef {import("@rspack/core").MultiCompiler} MultiCompiler */
+/** @typedef {import("../index.js").DevServerOption} DevServerOption */
+/** @typedef {import("../index.js").IncomingMessage} IncomingMessage */
+/** @typedef {import("../index.js").ServerResponse} ServerResponse */
+/**
+ * @template {IncomingMessage} Request
+ * @template {ServerResponse} Response
+ * @param {import("../index.js").WithOptional<import("../index.js").Context<Request, Response>, "watching" | "outputFileSystem">} context context
+ */
+declare function setupOutputFileSystem<
+  Request extends IncomingMessage,
+  Response extends ServerResponse,
+>(
+  context: import("../index.js").WithOptional<
+    import("../index.js").Context<Request, Response>,
+    "watching" | "outputFileSystem"
+  >,
+): void;

package/types/utils/setupWriteToDisk.d.ts

@@ -0,0 +1,21 @@
+export default setupWriteToDisk;
+export type Compiler = import("@rspack/core").Compiler;
+export type MultiCompiler = import("@rspack/core").MultiCompiler;
+export type Compilation = import("@rspack/core").Compilation;
+export type DevServerOption = import("../index.js").DevServerOption;
+export type IncomingMessage = import("../index.js").IncomingMessage;
+export type ServerResponse = import("../index.js").ServerResponse;
+/**
+ * @template {IncomingMessage} Request
+ * @template {ServerResponse} Response
+ * @param {import("../index.js").WithOptional<import("../index.js").Context<Request, Response>, "watching" | "outputFileSystem">} context context
+ */
+declare function setupWriteToDisk<
+  Request extends IncomingMessage,
+  Response extends ServerResponse,
+>(
+  context: import("../index.js").WithOptional<
+    import("../index.js").Context<Request, Response>,
+    "watching" | "outputFileSystem"
+  >,
+): void;

package/dist/index.d.ts

@@ -1,8 +0,0 @@
-import wdm from "webpack-dev-middleware";
-/** @deprecated
- *
- * This package has the same functionality as webpack-dev-middleware, please use webpack-dev-middleware instead.
- */
-declare const rdm: typeof wdm;
-export default rdm;
-//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,GAAG,MAAM,wBAAwB,CAAC;AAGzC;;;GAGG;AACH,QAAA,MAAM,GAAG,EAAE,OAAO,GAEqK,CAAC;AAExL,eAAe,GAAG,CAAC"}

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;AAAA,oFAAyC;AACzC,gDAAwB;AAExB;;;GAGG;AACH,MAAM,GAAG,GAAe,cAAI,CAAC,SAAS,CAAC,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE;IAC5D,OAAO,IAAA,gCAAG,EAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;AAC/B,CAAC,EAAE,mLAAmL,CAAC,CAAC;AAExL,kBAAe,GAAG,CAAC"}

package/index.cjs

@@ -1,2 +0,0 @@
-module.exports = require("./dist/index.js").default;
-module.exports.default = module.exports; // compatible with old require('xxx').default