@stencil/dev-server

  • Version 5.0.0-next.0
  • Published
  • 131 kB
  • 3 dependencies
  • MIT license

Install

npm i @stencil/dev-server
yarn add @stencil/dev-server
pnpm add @stencil/dev-server

Overview

Development server for Stencil with DOM-based HMR

Index

Variables

variable BUILD_LOG

const BUILD_LOG: string;

    variable BUILD_RESULTS

    const BUILD_RESULTS: string;

      variable BUILD_STATUS

      const BUILD_STATUS: string;

        variable DEV_SERVER_INIT_URL

        const DEV_SERVER_INIT_URL: string;

          variable DEV_SERVER_URL

          const DEV_SERVER_URL: string;
          • Client-side constants for dev server.

          variable NODE_TYPE_DOCUMENT_FRAGMENT

          const NODE_TYPE_DOCUMENT_FRAGMENT: number;

            variable NODE_TYPE_ELEMENT

            const NODE_TYPE_ELEMENT: number;

              variable NORMAL_CLOSURE_CODE

              const NORMAL_CLOSURE_CODE: number;

                variable OPEN_IN_EDITOR_URL

                const OPEN_IN_EDITOR_URL: string;

                  variable RECONNECT_ATTEMPTS

                  const RECONNECT_ATTEMPTS: number;

                    variable RECONNECT_RETRY_MS

                    const RECONNECT_RETRY_MS: number;

                      variable REQUEST_BUILD_RESULTS_INTERVAL_MS

                      const REQUEST_BUILD_RESULTS_INTERVAL_MS: number;

                        Functions

                        function appError

                        appError: (data: AppErrorData) => AppErrorResults;

                          function clearAppErrorModal

                          clearAppErrorModal: (data: { window: Window }) => void;

                            function emitBuildLog

                            emitBuildLog: (win: Window, buildLog: BuildLog) => void;

                              function emitBuildResults

                              emitBuildResults: (win: Window, buildResults: CompilerBuildResults) => void;

                                function emitBuildStatus

                                emitBuildStatus: (win: Window, buildStatus: string) => void;

                                  function hmrWindow

                                  hmrWindow: (data: HmrWindowData) => HmrResults;

                                    function initBuildProgress

                                    initBuildProgress: (data: { window: Window }) => void;

                                      function initBuildStatus

                                      initBuildStatus: (data: { window: Window }) => void;
                                      • Build status and favicon utilities for dev server client.

                                      function initClientWebSocket

                                      initClientWebSocket: (win: DevClientWindow, config: DevClientConfig) => void;

                                        function initDevClient

                                        initDevClient: (win: DevClientWindow, config: DevClientConfig) => void;

                                          function logBuild

                                          logBuild: (msg: string) => void;

                                            function logDiagnostic

                                            logDiagnostic: (diag: Diagnostic) => void;

                                              function logDisabled

                                              logDisabled: (prefix: string, msg: string) => void;

                                                function logReload

                                                logReload: (msg: string) => void;

                                                  function logWarn

                                                  logWarn: (prefix: string, msg: string) => void;

                                                    function onBuildLog

                                                    onBuildLog: (win: Window, cb: (buildLog: BuildLog) => void) => void;

                                                      function onBuildResults

                                                      onBuildResults: (
                                                      win: Window,
                                                      cb: (buildResults: CompilerBuildResults) => void
                                                      ) => void;

                                                        function onBuildStatus

                                                        onBuildStatus: (win: Window, cb: (buildStatus: string) => void) => void;

                                                          function updateFavIcon

                                                          updateFavIcon: (linkElm: HTMLLinkElement, status: string) => void;

                                                            Interfaces

                                                            interface BuildLog

                                                            interface BuildLog {}

                                                              property buildId

                                                              buildId: number;

                                                                property messages

                                                                messages: string[];

                                                                  property progress

                                                                  progress: number;

                                                                    interface DevClientConfig

                                                                    interface DevClientConfig {}

                                                                      property basePath

                                                                      basePath: string;

                                                                        property editors

                                                                        editors: DevServerEditor[];

                                                                          property reloadStrategy

                                                                          reloadStrategy: 'hmr' | 'pageReload' | null;

                                                                            property socketUrl

                                                                            socketUrl?: string;

                                                                              interface DevClientWindow

                                                                              interface DevClientWindow extends Window {}

                                                                                property 's-build-id'

                                                                                's-build-id'?: number;

                                                                                  property 's-dev-server'

                                                                                  's-dev-server'?: boolean;

                                                                                    property 's-initial-load'

                                                                                    's-initial-load'?: boolean;

                                                                                      property devServerConfig

                                                                                      devServerConfig?: DevClientConfig;

                                                                                        property WebSocket

                                                                                        WebSocket: typeof WebSocket;

                                                                                          interface DevServerEditor

                                                                                          interface DevServerEditor {}

                                                                                            property id

                                                                                            id: string;

                                                                                              property name

                                                                                              name?: string;

                                                                                                interface DevServerMessage

                                                                                                interface DevServerMessage {}

                                                                                                  property buildLog

                                                                                                  buildLog?: BuildLog;

                                                                                                    property buildResults

                                                                                                    buildResults?: CompilerBuildResults;

                                                                                                      property isActivelyBuilding

                                                                                                      isActivelyBuilding?: boolean;

                                                                                                        property requestBuildResults

                                                                                                        requestBuildResults?: boolean;

                                                                                                          interface HmrResults

                                                                                                          interface HmrResults {}

                                                                                                            property updatedComponents

                                                                                                            updatedComponents: string[];

                                                                                                              property updatedExternalStyles

                                                                                                              updatedExternalStyles: string[];

                                                                                                                property updatedImages

                                                                                                                updatedImages: string[];

                                                                                                                  property updatedInlineStyles

                                                                                                                  updatedInlineStyles: string[];

                                                                                                                    property versionId

                                                                                                                    versionId: string;

                                                                                                                      interface HostElement

                                                                                                                      interface HostElement extends Element {}

                                                                                                                        property 's-hmr'

                                                                                                                        's-hmr'?: (versionId: string) => void;

                                                                                                                          interface OpenInEditorData

                                                                                                                          interface OpenInEditorData {}

                                                                                                                            property column

                                                                                                                            column?: number;

                                                                                                                              property editor

                                                                                                                              editor?: string;

                                                                                                                                property file

                                                                                                                                file?: string;

                                                                                                                                  property line

                                                                                                                                  line?: number;

                                                                                                                                    Package Files (1)

                                                                                                                                    Dependencies (3)

                                                                                                                                    Dev Dependencies (3)

                                                                                                                                    Peer Dependencies (1)

                                                                                                                                    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/@stencil/dev-server.

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