Logo for jsDocs.io

nexe

  • Version 5.0.0-beta.4
  • Published
  • 1.64 MB
  • 19 dependencies
  • MIT license

Install

npm i nexe
yarn add nexe
pnpm add nexe

Overview

Create a single executable out of your Node.js application

Index

Variables

Functions

Classes

Interfaces

Variables

variable argv

const argv: parseArgv.ParsedArgs;

    variable help

    let help: string;

      variable version

      const version: string;

        Functions

        function compile

        compile: (
            compilerOptions?: Partial<NexeOptions>,
            callback?: (err: Error | null) => void
        ) => Promise<void>;

          Classes

          class NexeCompiler

          class NexeCompiler {}

            constructor

            constructor(options: NexeOptions);

              property bundle

              bundle: Bundle;

              • Virtual FileSystem

              property configureScript

              configureScript: string;

              • Path to the configure script

              property entrypoint

              entrypoint: string;

              • The main entrypoint filename for your application - eg. node mainFile.js

              property env

              env: { [x: string]: string; TZ?: string | undefined };

              • Copy of process.env

              property files

              files: NexeFile[];

              • In memory files that are being manipulated by the compiler

              property log

              log: Logger;

                property nodeSrcBinPath

                nodeSrcBinPath: string;

                • The file path of node binary

                property options

                options: NexeOptions;

                  property output

                  output: string;

                  • Output filename (-o myapp.exe)

                  property remoteAsset

                  remoteAsset: string;

                  • Remote asset path if available

                  property shims

                  shims: string[];

                  • Standalone pieces of code run before the application entrypoint

                  property src

                  src: string;

                  • Root directory for the source of the current build

                  property startup

                  startup: string;

                  • The last shim (defaults to "require('module').runMain()")

                  property stdinUsed

                  stdinUsed: boolean;

                  • Flag to indicate whether or notstdin was used for input

                  property target

                  target: NexeTarget;

                  • Current target of the compiler

                  property targets

                  targets: NexeTarget[];

                  • Not used

                  method addResource

                  addResource: (
                      absoluteFileName: string,
                      content?: Buffer | string | File
                  ) => void;

                    method assertBuild

                    assertBuild: () => void;

                      method build

                      build: () => Promise<ReadStream>;

                        method code

                        code: () => string;

                          method compileAsync

                          compileAsync: (target: NexeTarget) => Promise<Readable>;

                            method getNodeExecutableLocation

                            getNodeExecutableLocation: (target?: NexeTarget) => string;

                              method quit

                              quit: (error?: any) => Promise<unknown>;

                                method readFileAsync

                                readFileAsync: (file: string) => Promise<NexeFile>;

                                  method replaceInFileAsync

                                  replaceInFileAsync: (
                                      file: string,
                                      replace: string | RegExp,
                                      value: string | StringReplacer
                                  ) => Promise<void>;

                                    method setFileContentsAsync

                                    setFileContentsAsync: (file: string, contents: string | Buffer) => Promise<void>;

                                      method writeFileAsync

                                      writeFileAsync: (file: string, contents: string | Buffer) => Promise<void>;

                                        Interfaces

                                        interface NexeOptions

                                        interface NexeOptions {}

                                          property asset

                                          asset: string;

                                            property build

                                            build: boolean;

                                              property bundle

                                              bundle: boolean | string;

                                                property clean

                                                clean?: boolean;

                                                  property configure

                                                  configure: string[];

                                                    property cwd

                                                    cwd: string;

                                                      property debugBundle

                                                      debugBundle?: boolean;

                                                        property downloadOptions

                                                        downloadOptions: any;

                                                        • Api Only

                                                        property enableNodeCli

                                                        enableNodeCli: boolean;

                                                          property enableStdIn

                                                          enableStdIn?: boolean;

                                                            property fakeArgv

                                                            fakeArgv?: boolean;

                                                              property flags

                                                              flags: string[];

                                                                property fs

                                                                fs: boolean | string[];

                                                                  property ghToken

                                                                  ghToken: string;

                                                                    property ico

                                                                    ico?: string;

                                                                      property info

                                                                      info?: boolean;

                                                                        property input

                                                                        input: string;

                                                                          property loglevel

                                                                          loglevel: 'info' | 'silent' | 'verbose';

                                                                            property make

                                                                            make: string[];

                                                                              property mangle

                                                                              mangle: boolean;

                                                                                property name

                                                                                name: string;

                                                                                  property native

                                                                                  native: any;

                                                                                    property output

                                                                                    output: string;

                                                                                      property patches

                                                                                      patches: (string | NexePatch)[];

                                                                                        property plugins

                                                                                        plugins: (string | NexePatch)[];

                                                                                          property python

                                                                                          python?: string;

                                                                                            property rc

                                                                                            rc: {
                                                                                                [key: string]: string;
                                                                                            };

                                                                                              property remote

                                                                                              remote: string;

                                                                                                property resources

                                                                                                resources: string[];

                                                                                                  property silent

                                                                                                  silent?: boolean;

                                                                                                    property snapshot

                                                                                                    snapshot?: string;

                                                                                                      property sourceUrl

                                                                                                      sourceUrl?: string;

                                                                                                        property targets

                                                                                                        targets: (string | NexeTarget)[];

                                                                                                          property temp

                                                                                                          temp: string;

                                                                                                            property vcBuild

                                                                                                            vcBuild: string[];

                                                                                                              property verbose

                                                                                                              verbose?: boolean;

                                                                                                                property warmup

                                                                                                                warmup?: string;

                                                                                                                  Package Files (3)

                                                                                                                  Dependencies (19)

                                                                                                                  Dev Dependencies (23)

                                                                                                                  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/nexe.

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