@types/node-static

  • Version 0.7.11
  • Published
  • 5.55 kB
  • 2 dependencies
  • MIT license

Install

npm i @types/node-static
yarn add @types/node-static
pnpm add @types/node-static

Overview

TypeScript definitions for node-static

Index

Variables

variable version

const version: [number, number, number];

    Classes

    class Server

    class Server {}

      constructor

      constructor(root: string, options?: Options);

        property cache

        cache: number | boolean;

          property defaultHeaders

          defaultHeaders: Headers;

            property finish

            finish: (
            status: number,
            headers: Headers,
            req: http.IncomingMessage,
            res: http.ServerResponse,
            promise: events.EventEmitter,
            callback: Callback
            ) => void;

              property gzipOk

              gzipOk: (req: http.IncomingMessage, contentType: string) => boolean;

                property options

                options: Options;

                  property parseByteRange

                  parseByteRange: (req: http.IncomingMessage, stat: fs.Stats) => ByteRange;

                    property resolve

                    resolve: (pathname: string) => string;

                      property respond

                      respond: (
                      pathname: string,
                      status: number,
                      _headers: Headers,
                      files: string[],
                      stat: fs.Stats,
                      req: http.IncomingMessage,
                      res: http.ServerResponse,
                      finish: Finish
                      ) => void;

                        property respondGzip

                        respondGzip: (
                        pathname: string,
                        status: number,
                        contentType: string,
                        _headers: Headers,
                        files: string[],
                        stat: fs.Stats,
                        req: http.IncomingMessage,
                        res: http.ServerResponse,
                        finish: Finish
                        ) => void;

                          property respondNoGzip

                          respondNoGzip: (
                          pathname: string,
                          status: number,
                          contentType: string,
                          _headers: Headers,
                          files: string[],
                          stat: fs.Stats,
                          req: http.IncomingMessage,
                          res: http.ServerResponse,
                          finish: Finish
                          ) => void;

                            property root

                            root: string;

                              property serve

                              serve: (
                              req: http.IncomingMessage,
                              res: http.ServerResponse,
                              callback?: Callback
                              ) => events.EventEmitter;

                                property serveDir

                                serveDir: (
                                pathname: string,
                                req: http.IncomingMessage,
                                res: http.ServerResponse,
                                finish: Finish
                                ) => void;

                                  property serveFile

                                  serveFile: (
                                  pathname: string,
                                  status: number,
                                  headers: Headers,
                                  req: http.IncomingMessage,
                                  res: http.ServerResponse
                                  ) => events.EventEmitter;

                                    property servePath

                                    servePath: (
                                    pathname: string,
                                    status: number,
                                    headers: Headers,
                                    req: http.IncomingMessage,
                                    res: http.ServerResponse,
                                    finish: Finish
                                    ) => events.EventEmitter;

                                      property serverInfo

                                      serverInfo: string;

                                        property stream

                                        stream: (
                                        pathname: string,
                                        files: string[],
                                        length: number,
                                        startByte: number,
                                        res: http.ServerResponse,
                                        callback: Callback
                                        ) => void;

                                          Interfaces

                                          interface ByteRange

                                          interface ByteRange {}

                                            property from

                                            from: number;

                                              property to

                                              to: number;

                                                property valid

                                                valid: boolean;

                                                  interface Headers

                                                  interface Headers {}

                                                    index signature

                                                    [k: string]: any;

                                                      interface Options

                                                      interface Options {}

                                                        property "cache-control"

                                                        'cache-control'?: string | undefined;

                                                          property cache

                                                          cache?: number | boolean | undefined;

                                                            property headers

                                                            headers?: Headers | undefined;

                                                              property indexFile

                                                              indexFile?: string | undefined;

                                                                property server

                                                                server?: string | undefined;

                                                                  property serverInfo

                                                                  serverInfo?: Buffer | undefined;

                                                                    Type Aliases

                                                                    type Callback

                                                                    type Callback = (e: Error) => void;

                                                                      type Finish

                                                                      type Finish = (status: number, headers?: Headers) => void;

                                                                        Package Files (1)

                                                                        Dependencies (2)

                                                                        Dev Dependencies (0)

                                                                        No dev dependencies.

                                                                        Peer Dependencies (0)

                                                                        No peer dependencies.

                                                                        Badge

                                                                        To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                        You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/node-static.

                                                                        • Markdown
                                                                          [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@types/node-static)
                                                                        • HTML
                                                                          <a href="https://www.jsdocs.io/package/@types/node-static"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>