Neutralinojs

https://neutralino.js.org/docs
Admin
Neutralinojs is a lightweight, portable, and cross-platform desktop application development...
Tokens:53,240
Snippets:742
Trust Score:8.1
Update:2 months ago
Show doc for...
Tokens:
Raw
### Clone and setup the client repository

Source: https://neutralino.js.org/docs/contributing/framework-developer-guide

Initializes the client environment by cloning the repository and installing dependencies.

```bash
git clone https://github.com/neutralinojs/neutralino.js.git  
cd neutralino.js  
```

```bash
npm install  
```

--------------------------------

### Install neu CLI

Source: https://neutralino.js.org/docs/cli/neu-cli

Global installation of the CLI tool via npm.

```bash
npm i -g @neutralinojs/neu
```

--------------------------------

### Neutralinojs configuration example

Source: https://neutralino.js.org/docs/getting-started/your-first-neutralinojs-app

Example of the nativeAllowList configuration in Neutralinojs, showing permissions for OS and app functionalities.

```json
"nativeAllowList": [
    "app.*",
    "os.*",
    "debug.log"
],

```

--------------------------------

### Install Neutralinojs Client Library

Source: https://neutralino.js.org/docs/getting-started/using-frontend-libraries

Install the required client library package within your frontend project directory.

```bash
cd react-src  
npm install @neutralinojs/lib  
```

--------------------------------

### Install neu CLI

Source: https://neutralino.js.org/docs/getting-started/your-first-neutralinojs-app

Install the Neutralinojs command-line interface globally to manage your projects.

```bash
npm install -g @neutralinojs/neu  
```

--------------------------------

### Install Fedora dependencies

Source: https://neutralino.js.org/docs/contributing/framework-developer-guide

Command to install development tools and libraries on Fedora systems.

```bash
sudo dnf install \
    @development-tools \
    gtk3 \
    webkit2gtk3.x86_64 \
    webkit2gtk3-devel.x86_64 \
    libgtk-3-dev \
    libwebkit2gtk-4.1-0 \
 # or libwebkit2gtk-4.0-37  
    libglib2.0-dev \
    libxrandr-dev \
    cmake \
    ninja-build  
```

--------------------------------

### Start Neutralinojs via CLI arguments

Source: https://neutralino.js.org/docs/configuration/neutralino.config.json

Launch the framework without a configuration file by passing parameters directly to the binary.

```bash
# Loading a remote URL  
./framework-bin --url=https://neutralino.js.org/docs  
  
# Launches a local static web app  
./framework-bin --url="/" --document-root="/resources/" --window-title="My web app" --enable-server --enable-native-api
```

--------------------------------

### Install Debian dependencies

Source: https://neutralino.js.org/docs/contributing/framework-developer-guide

Commands to install required build tools and WebKit libraries on Debian-based systems.

```bash
sudo apt install libgtk-3-dev cmake ninja-build  
```

```bash
sudo apt install libwebkit2gtk-4.1-0  
# --- or ---  
sudo apt install libwebkit2gtk-4.0-37  
```

--------------------------------

### Install Update and Restart - Neutralinojs

Source: https://neutralino.js.org/docs/how-to/auto-updater

Compares the downloaded manifest version with the current app version. If an update is available, it installs the update and restarts the application process.

```javascript
try {
    let url = "http://example.com/updater_test/update_manifest.json";
    let manifest = await Neutralino.updater.checkForUpdates(url);

    if(manifest.version != NL_APPVERSION) {
        await Neutralino.updater.install();
        await Neutralino.app.restartProcess();
    }
} catch(err) {
    // Handle errors
}

```

--------------------------------

### Install Arch dependencies

Source: https://neutralino.js.org/docs/contributing/framework-developer-guide

Command to install build dependencies on Arch Linux.

```bash
sudo pacman -S \
    gtk3 \
    webkit2gtk \
    cmake \
    ninja  
```

--------------------------------

### Install jq dependency

Source: https://neutralino.js.org/docs/distribution/overview

Install the jq utility, which is required for parsing JSON configuration files during the build process.

```bash
# On macOS:  
brew install jq  
# On Linux or Windows/WSL:  
sudo apt-get install jq  
```

--------------------------------

### Install macOS dependencies

Source: https://neutralino.js.org/docs/contributing/framework-developer-guide

Command to install CMake and Ninja using Homebrew on macOS.

```bash
brew install cmake ninja  
```

--------------------------------

### Install Update

Source: https://neutralino.js.org/docs/how-to/auto-updater

Installs the application update based on the previously fetched update manifest.

```APIDOC
## Install Update

This function initiates the installation of a new application version using the downloaded update manifest.

### Method

`Neutralino.updater.install()`

### Description

This method should be called after `Neutralino.updater.checkForUpdates` has successfully returned a manifest with a newer version.

### Example

```javascript
try {
    // Assuming 'manifest' is obtained from Neutralino.updater.checkForUpdates
    // and manifest.version is newer than NL_APPVERSION
    await Neutralino.updater.install();
    console.log("Update installation initiated.");
    // It's recommended to restart the application after installation
    await Neutralino.app.restartProcess();
} catch(err) {
    console.error("Error installing update:", err);
}
```
```

--------------------------------

### Initialize and Control Neutralinojs App with Node.js Bindings

Source: https://neutralino.js.org/docs/release-notes/cli

This example demonstrates launching Neutralinojs via Node.js and executing native APIs using the `node-neutralino` package. It initializes the app with custom window options and sets the window title.

```javascript
import NeutralinoApp from 'node-neutralino';

const app = new NeutralinoApp({
  url: '/',
  windowOptions: {
    enableInspector: false,
  }
});

app.init();
app.window.setTitle('Node.js');
```

--------------------------------

### Define Windows-specific application configuration

Source: https://neutralino.js.org/docs/configuration/neutralino.config.json

Example of a neutralino.config.json file including metadata fields like applicationName, author, and applicationIcon for Windows executables.

```json
{
    "applicationId": "cook.pancake.bakery",
    "version": "1.2.0",
    "applicationName": "Pancake Bakery",
    "author": "Sweet Pancakes LLC",
    "description": "Digital recipe book for pancakes from all over the world",
    "copyright": "Copyright © Sweet Pancakes LLC 2042. All rights reserved.",
    "applicationIcon": "buildAssets/appIcon.png",
    "cli": {
        "binaryName": "pancakebakery"
    }
}
```

--------------------------------

### updater.install()

Source: https://neutralino.js.org/docs/api/updater

Installs updates based on a previously downloaded update manifest. This function will throw an error if the manifest has not been loaded or if the update installation process fails.

```APIDOC
## updater.install()

### Description
Installs updates from the downloaded update manifest. Throws `NE_UP_UPDNOUF` if the manifest isn't loaded. If the update installation process fails, this function will throw `NE_UP_UPDINER`.

### Example
```javascript
let url = 'https://example.com/updates/manifest.json';  
let manifest = await Neutralino.updater.checkForUpdates(url);  
  
if(manifest.version != NL_APPVERSION) {  
    await Neutralino.updater.install();  
}
else {
    console.log('You are using the latest version!');
}
```
```

--------------------------------

### Run neu CLI via npx

Source: https://neutralino.js.org/docs/cli/neu-cli

Execute CLI commands without a global installation.

```bash
npx @neutralinojs/neu <command>
```

--------------------------------

### Install missing Linux dependencies

Source: https://neutralino.js.org/docs/contributing/frequently-asked-questions

Commands to resolve Error Code 127 by installing the required libayatana-appindicator3-1 package on Debian-based systems.

```bash
apt update  
apt install -y libayatana-appindicator3-1  
```

--------------------------------

### Get application configuration

Source: https://neutralino.js.org/docs/api/app

Returns the current application configuration as a JSON object.

```javascript
let config = await Neutralino.app.getConfig();  
console.log('URL = ', config.url);
```

--------------------------------

### Convenience Methods (get, post, put, patch, delete, options, head)

Source: https://neutralino.js.org/docs/api/net

Simplified methods for performing specific HTTP requests, all sharing the same signature and behavior as net.request.

```APIDOC
## Neutralino.net Convenience Methods

- **net.get(url, options)**
- **net.post(url, options)**
- **net.put(url, options)**
- **net.patch(url, options)**
- **net.delete(url, options)**
- **net.options(url, options)**
- **net.head(url, options)**

### Description
These methods are wrappers around `net.request` that automatically set the HTTP method. All parameters, options, and return values are identical to `net.request`.
```

--------------------------------

### Initialize a custom frontend project

Source: https://neutralino.js.org/docs/getting-started/using-frontend-libraries

Steps to create a base Neutralinojs project and a nested frontend framework project.

```bash
neu create myapp --template neutralinojs/neutralinojs-zero  
```

```bash
cd myapp  
npx create-react-app react-src  
```

--------------------------------

### Install Updates with Neutralino.updater

Source: https://neutralino.js.org/docs/api/updater

Installs updates after checking for them. This function requires a previously loaded update manifest. It will throw an error if no manifest is loaded or if the installation process fails.

```javascript
let url = 'https://example.com/updates/manifest.json';
let manifest = await Neutralino.updater.checkForUpdates(url);

if(manifest.version != NL_APPVERSION) {
    await Neutralino.updater.install();
}
else {
    console.log('You are using the latest version!');
}
```

--------------------------------

### Initialization with Ready Event Callback

Source: https://neutralino.js.org/docs/api/init

Shows how to initialize the application and wrap subsequent native API calls within the `ready` event callback.

```APIDOC
## Neutralino.init() with ready event

### Description
Initializes the Neutralinojs application and optionally wraps native API calls within the `ready` event callback. This ensures native calls are made after the application is fully ready.

### Usage
```javascript
Neutralino.init();
Neutralino.events.on('ready', () => {
    Neutralino.os.showMessageBox('Welcome', 'Hello Neutralinojs');
});
```
```

--------------------------------

### Get all mounted directories with Neutralino.server

Source: https://neutralino.js.org/docs/api/server

Call `server.getMounts` to retrieve a map of all currently active directory mount configurations. This is useful for debugging or verifying active mounts.

```javascript
let mounts = await Neutralino.server.getMounts();  
console.log('Mounts:', mounts);  
```

--------------------------------

### Create and run a React template project

Source: https://neutralino.js.org/docs/getting-started/using-frontend-libraries

Commands to initialize a project using a pre-configured React template and execute it.

```bash
neu create myapp --template codezri/neutralinojs-react  
cd myapp  
  
# Start the React development server with Neutralinojs  
neu run  
  
# Build the React and Neutralinojs app  
neu build  
```

--------------------------------

### Build and Run with Inspector

Source: https://neutralino.js.org/docs/getting-started/using-frontend-libraries

Build the frontend and launch the application with the inspector enabled for debugging.

```bash
cd react-src  
npm run build  
  
cd ..  
neu run -- --window-enable-inspector  
```

--------------------------------

### Configure CLI and build the application

Source: https://neutralino.js.org/docs/getting-started/using-frontend-libraries

Settings to manage the client library and commands to build and run the integrated application.

```json
  "cli": {  
    // --- other options  
    "resourcesPath": "/react-src/build/",  
    // ---  
    "clientLibrary": "/www/neutralino.js", // <--- Remove this option  
    // ---  
  }  
```

```bash
cd react-src  
npm run build  
```

```bash
cd ..  
neu run  
```

--------------------------------

### Basic Initialization and API Call

Source: https://neutralino.js.org/docs/api/init

Demonstrates the basic usage of `Neutralino.init()` followed by a native API call.

```APIDOC
## Neutralino.init()

### Description
Initializes the Neutralinojs application and establishes a WebSocket connection with the Neutralinojs server. This function must be called before any other native API functions.

### Usage
```javascript
Neutralino.init();
Neutralino.os.showMessageBox('Welcome', 'Hello Neutralinojs');
```
```

--------------------------------

### Load custom configuration file

Source: https://neutralino.js.org/docs/release-notes/framework

Use the --config-file command-line parameter to specify a custom configuration file during application startup.

```bash
./myapp-linux_x64 --load-dir-res --config-file=neutralino-dev.config.json  
```

--------------------------------

### Initialize Neutralinojs without a configuration file

Source: https://neutralino.js.org/docs/release-notes/framework

Launch the framework using CLI arguments to specify a remote URL or a local static web app directory without requiring a neutralino.config.json file.

```bash
# Loading a remote URL  
./framework-bin --url=https://neutralino.js.org/docs  
  
# Launches a local static web app  
./framework-bin --url="/resources/" --window-title="My web app" --enable-server
```

--------------------------------

### Create a New Window with Options

Source: https://neutralino.js.org/docs/api/window

Use this to create a new application window with custom configurations. Specify options like icon, inspector enablement, dimensions, and process arguments.

```javascript
await Neutralino.window.create('/resources/aboutWindow.html', {
    icon: '/resources/icons/aboutIcon.png',
    enableInspector: false,
    width: 500,
    height: 300,
    maximizable: false,
    exitProcessOnClose: true,
    processArgs: '--window-id=W_ABOUT'
});
```

--------------------------------

### Configure document root and URL

Source: https://neutralino.js.org/docs/configuration/neutralino.config.json

Set the document root for the static server and ensure the URL is configured correctly to avoid path resolution errors.

```json
{
    "documentRoot": "/resources/",
    "url": "/"
}
```

```json
{
    "documentRoot": "/resources/",
    "url": "/resources/"
}
```

```json
{
    "documentRoot": "/",
    "url": "/resources/"
}
```

--------------------------------

### Get all environment variables

Source: https://neutralino.js.org/docs/api/os

Retrieves all environment variables as a key-value object.

```javascript
let envs = await Neutralino.os.getEnvs();  
console.log(envs);  

```

--------------------------------

### Compile the project

Source: https://neutralino.js.org/docs/contributing/framework-developer-guide

Command to execute the build process using Ninja.

```bash
ninja -C build  
```

--------------------------------

### Get process identifier

Source: https://neutralino.js.org/docs/api/app

Retrieves the PID of the current application instance.

```javascript
let pid = await Neutralino.app.getProcessId();  
console.log('PID = ', pid);
```

--------------------------------

### Create a new Neutralinojs app

Source: https://neutralino.js.org/docs/getting-started/your-first-neutralinojs-app

Scaffold a new Neutralinojs application project using the 'create' command.

```bash
neu create myapp  
```

--------------------------------

### Get Window Title

Source: https://neutralino.js.org/docs/api/window

Retrieves the current title of the native window instance.

```javascript
let title = await Neutralino.window.getTitle();
console.log(`title = ${title}`);
```

--------------------------------

### Create build directory

Source: https://neutralino.js.org/docs/contributing/framework-developer-guide

Commands to create the build directory for different operating systems.

```bash
mkdir build  
```

```bash
mkdir -p build  
```

```bash
mkdir build  
```

--------------------------------

### Get mouse position

Source: https://neutralino.js.org/docs/api/computer

Retrieves the current mouse cursor coordinates relative to the screen.

```javascript
let pos = await Neutralino.computer.getMousePosition();  
console.log(`Pos: ${pos.x}, ${pos.y}`);
```

--------------------------------

### Neutralino.window.create

Source: https://neutralino.js.org/docs/api/window

Creates a new application window with specified options. You can configure various properties like title, icon, size, and behavior.

```APIDOC
## Neutralino.window.create(url, options)

### Description
Creates a new application window with the specified URL and options.

### Parameters
#### Path Parameters
- **url** (String): The URL of the HTML file to load in the new window.

#### Request Body
- **options** (WindowOptions): An object containing various configuration options for the window.
  - `title` (String): Window title.
  - `icon` (String): Window icon path.
  - `fullScreen` (Boolean): Sets full screen mode.
  - `alwaysOnTop` (Boolean): Activates the top-most mode.
  - `enableInspector` (Boolean): Activates developer tools and opens the web inspector window.
  - `borderless` (Boolean): Makes the window borderless.
  - `maximize` (Boolean): Launches the window maximized.
  - `hidden` (Boolean): Hides the window.
  - `maximizable` (Boolean): Makes the window maximizable or not.
  - `exitProcessOnClose` (Boolean): Exits the application process when the user clicks the window's close button.
  - `width` (Number): Window width.
  - `height` (Number): Window height.
  - `x` (Number): Window `x` position.
  - `y` (Number): Window `y` position.
  - `minWidth` (Number): Minimum width of the window.
  - `minHeight` (Number): Minimum height of the window.
  - `maxWidth` (Number): Maximum width of the window.
  - `maxHeight` (Number): Maximum height of the window.
  - `extendUserAgentWith` (String): Extends the user agent string of the webview instance.
  - `injectGlobals` (Boolean): Injects global variables directly to the webview instance.
  - `injectClientLibrary` (Boolean): Injects the client library source directly to the webview instance.
  - `injectScript` (Boolean): A preload JavaScript source file that executes before web app resources.
  - `processArgs` (String): Additional command-line arguments for the new window process.

### Return Object (awaited)
- `pid` (Number): Process identifier.
- `stdOut` (String): Standard output. This value is always empty since the new window process starts asynchronously.
- `stdErr` (String): Standard error. This value is always empty since the new window process starts asynchronously.
- `exitCode` (Number): Exit code of the process.

### Request Example
```javascript
await Neutralino.window.create('/resources/aboutWindow.html', {
    icon: '/resources/icons/aboutIcon.png',
    enableInspector: false,
    width: 500,
    height: 300,
    maximizable: false,
    exitProcessOnClose: true,
    processArgs: '--window-id=W_ABOUT'
});
```
```

--------------------------------

### Get system locale with os.getLocaleInfo

Source: https://neutralino.js.org/docs/api/os

Retrieves an object containing the current system locale, language, and region identifiers.

```javascript
let localeInfo = await Neutralino.computer.getLocaleInfo();  
console.log(`Locale: ${localeInfo.locale}`);  
```

--------------------------------

### Retrieve Operating System Information

Source: https://neutralino.js.org/docs/api/computer

Fetches OS name, description, and version details.

```javascript
let osInfo = await Neutralino.computer.getOSInfo();  
console.log(`OS: ${osInfo.name}`);  
```

--------------------------------

### Get File Permissions

Source: https://neutralino.js.org/docs/api/filesystem

Retrieves file permissions for a specified path. Throws an error if the path does not exist or is inaccessible.

```javascript
const permissions = await Neutralino.filesystem.getPermissions(NL_PATH + '/my-directory-1');
```

--------------------------------

### Get All Storage Keys

Source: https://neutralino.js.org/docs/api/storage

Retrieves and logs an array of all existing keys currently stored in Neutralinojs shared storage.

```javascript
let keys = await Neutralino.storage.getKeys();  
console.log('Keys: ', keys);
```

--------------------------------

### Define Extensions in neutralinojs.config.json

Source: https://neutralino.js.org/docs/how-to/extensions-overview

Configure extensions by providing their IDs and platform-specific startup commands in the `neutralinojs.config.json` file. Use path constants like `${NL_PATH}` for flexibility.

```json
"extensions": [
    {
        "id": "js.neutralino.sampleextension",
        "commandLinux": "${NL_PATH}/extensions/binary/linux/ext_bin",
        "commandDarwin": "${NL_PATH}/extensions/binary/mac/ext_bin",
        "commandWindows": "${NL_PATH}/extensions/binary/win/ext_bin.exe"
    },
    {
        "id": "js.neutralino.binaryextension",
        "command": "node ${NL_PATH}/extensions/binary/main.js"
    }
]
```

--------------------------------

### Get environment variable value

Source: https://neutralino.js.org/docs/api/os

Retrieves the value of a specific environment variable. Returns an empty string if the variable is undefined.

```javascript
let value = await Neutralino.os.getEnv('USER');  
console.log(`USER = ${value}`);  

```

--------------------------------

### Spawn a command with environment variables

Source: https://neutralino.js.org/docs/release-notes/framework

Use the options object to define the current working directory and environment variables for a spawned process.

```javascript
// e.g.:  
await Neutralino.os.spawnCommand('env', {  
  cwd: NL_PATH,  
  envs: {  
    VAR1: 'var1',  
    VAR2: 'var2'  
  }  
});  
```

--------------------------------

### Get Absolute Path

Source: https://neutralino.js.org/docs/api/filesystem

Converts a relative path to its absolute equivalent. This function is useful even if the path does not exist on the system.

```javascript
let path = await Neutralino.filesystem.getAbsolutePath('./myFolder');  
console.log(path);  
```

--------------------------------

### filesystem.createWatcher(path)

Source: https://neutralino.js.org/docs/api/filesystem

Sets up a filesystem watcher for a specified directory path. If a watcher already exists for the given path, it returns the existing watcher's identifier. Errors are thrown if watcher creation fails.

```APIDOC
## filesystem.createWatcher(path)

### Description
Creates a filesystem watcher for a specific directory path. Throws `NE_FS_UNLCWAT` for watcher creation failures. If there is an existing active watcher for the given path, this function returns the existing watcher identifier.

### Parameters
#### Path Parameters
- **path** (String): Directory path.

### Return Number
File watcher identifier.

### Request Example
```javascript
let watcherId = await Neutralino.filesystem.createWatcher(NL_PATH);
Neutralino.events.on('watchFile', (evt) => {
    if(watcherId == evt.detail.id) {
        console.log(evt.detail);
    }
});
console.log(`ID: ${watcherId}`);
```
```

--------------------------------

### Initialize Neutralinojs Client

Source: https://neutralino.js.org/docs/getting-started/using-frontend-libraries

Call the init function from the library in your application's main entry point.

```javascript
import React from 'react';  
import ReactDOM from 'react-dom';  
import './index.css';  
import App from './App';  
  
// Import init function from "@neutralinojs/lib"  
import { init } from "@neutralinojs/lib"  
  
ReactDOM.render(  
  <React.StrictMode>  
    <App />  
  </React.StrictMode>,  
  document.getElementById('root')  
);  
  
init(); // Add this function call  
```

--------------------------------

### Read Text File

Source: https://neutralino.js.org/docs/api/filesystem

Reads a text file. Can specify a starting position and size for reading. Throws NE_FS_FILRDER on error.

```javascript
let data = await Neutralino.filesystem.readFile('./myFile.txt');  
console.log(`Content: ${data}`);  

```

```javascript
let data = await Neutralino.filesystem.readFile('./myFile.txt', {  
    pos: 2,  
    size: 10  
});  
console.log(`Content: ${data}`);  

```

--------------------------------

### Create Filesystem Watcher

Source: https://neutralino.js.org/docs/api/filesystem

Sets up a watcher for a specific directory. If a watcher already exists for the path, its ID is returned. Event listeners should be set up to receive file change notifications.

```javascript
let watcherId = await Neutralino.filesystem.createWatcher(NL_PATH);
Neutralino.events.on('watchFile', (evt) => {
    if(watcherId == evt.detail.id) {
        console.log(evt.detail);
    }
});
console.log(`ID: ${watcherId}`);
```

--------------------------------

### Get File Watchers - Neutralino.js

Source: https://neutralino.js.org/docs/api/filesystem

Retrieves information about active file watchers. Iterates through the returned array to log details of each watcher.

```javascript
let watchers = await Neutralino.filesystem.getWatchers();  
for(let watcher of watchers) {  
    console.log(watcher);  
}
```

--------------------------------

### Get File Stream Info

Source: https://neutralino.js.org/docs/api/filesystem

Retrieves details about an opened file stream using its identifier. Throws an error if the identifier is invalid.

```javascript
let info = await Neutralino.filesystem.getOpenedFileInfo(0);
console.log(info);
```

--------------------------------

### Run the integration test suite

Source: https://neutralino.js.org/docs/contributing/framework-developer-guide

Executes the full integration test suite from the local machine.

```bash
cd spec  
npm install  
npm run test  
```

--------------------------------

### Move Window

Source: https://neutralino.js.org/docs/api/window

Moves the native window to the specified screen coordinates. The coordinate system starts from the top-left corner of the screen (0,0).

```javascript
await Neutralino.window.move(200, 400);
```

--------------------------------

### Build application binaries

Source: https://neutralino.js.org/docs/getting-started/using-frontend-libraries

Executes the build command to generate release binaries, ensuring the application bundle reflects the current project source.

```bash
neu build --release
```

--------------------------------

### Get All Resource Files

Source: https://neutralino.js.org/docs/api/resources

Retrieves a list of all files and directories embedded within the resource bundle. This is useful for understanding the structure of your loaded resources.

```javascript
let files = await Neutralino.resources.getFiles();
console.log('Files: ', files);
```

--------------------------------

### Get extension statistics

Source: https://neutralino.js.org/docs/api/extensions

Use `extensions.getStats` to retrieve an object containing arrays of loaded and connected extension identifiers. This is useful for monitoring extension status.

```javascript
let stats = await Neutralino.extensions.getStats();  
console.log('stats: ', stats);  
```

--------------------------------

### Configure WebView2 arguments

Source: https://neutralino.js.org/docs/release-notes/framework

Add custom browser arguments to the WebView2 instance on Windows via the configuration file.

```json
"modes": {  
  "window": {  
     // ....  
     "webviewArgs": "--user-agent=\"Custom user agent\""  
  }  
}  
```

--------------------------------

### Get Clipboard Data Format

Source: https://neutralino.js.org/docs/api/clipboard

Retrieves the current data format of the system clipboard. Use this to determine if the clipboard contains text, an image, or is empty.

```javascript
let format = await Neutralino.clipboard.getFormat();
console.log(`Format: ${format}`);
```

--------------------------------

### Fetch data using standard net API

Source: https://neutralino.js.org/docs/release-notes/framework

Demonstrates calling the standard network fetch method.

```javascript
let res = await Neutralino.net.fetch('https://neutralino.js.org');  
```

--------------------------------

### Start Window Dragging

Source: https://neutralino.js.org/docs/api/window

Enables the native window to be dragged by the user when the left mouse button is pressed. This is used internally by the draggable region API.

```javascript
await Neutralino.window.beginDrag();
```

--------------------------------

### Show Window

Source: https://neutralino.js.org/docs/api/window

Makes the native window visible.

```javascript
await Neutralino.window.show();
```

--------------------------------

### os.showOpenDialog(title, options)

Source: https://neutralino.js.org/docs/api/os

Displays a native file open dialog.

```APIDOC
## os.showOpenDialog(title, options)

### Description
Shows the file open dialog to obtain paths of existing files.

### Parameters
- **title** (String) - Optional - Title of the dialog.
- **options** (Object) - Optional - Configuration object containing filters, multiSelections, and defaultPath.

### Return
- **Object** (awaited) - An array of selected entries.
```

--------------------------------

### Get Window Position

Source: https://neutralino.js.org/docs/api/window

Fetches the current coordinates (x, y) of the window's top-left corner on the screen. This can be useful for positioning other UI elements relative to the window.

```javascript
let position = await Neutralino.window.getPosition();  
  
console.log(position);  
```

--------------------------------

### Clone the Neutralinojs repository

Source: https://neutralino.js.org/docs/contributing/framework-developer-guide

Initial step to download the source code and enter the project directory.

```bash
git clone https://github.com/neutralinojs/neutralinojs.git  
cd neutralinojs  
```

--------------------------------

### Build application for release

Source: https://neutralino.js.org/docs/getting-started/your-first-neutralinojs-app

Builds portable binaries for your Neutralinojs application and packages them into a .zip file when the --release flag is used.

```bash
neu build --release  
```

--------------------------------

### Get User Data from Storage

Source: https://neutralino.js.org/docs/api/storage

Reads and logs user details from Neutralinojs shared storage using a specified key. Ensure data has been previously set.

```javascript
let data = await Neutralino.storage.getData('userDetails');  
console.log(`Data: ${data}`);
```

--------------------------------

### Run the Neutralinojs app

Source: https://neutralino.js.org/docs/getting-started/your-first-neutralinojs-app

Navigate to your application directory and run the application using the 'run' command.

```bash
cd myapp  
neu run  
```

--------------------------------

### Get All Custom Methods - Neutralino.custom.getMethods()

Source: https://neutralino.js.org/docs/api/custom

Retrieves a list of all custom method identifiers that have been added by the application developer. This is useful for introspection and understanding available custom functionalities.

```javascript
let methods = await Neutralino.custom.getMethods();
console.log(methods);
```

--------------------------------

### Retrieve Hostname

Source: https://neutralino.js.org/docs/api/computer

Returns the system hostname.

```javascript
let hostname = await Neutralino.computer.getHostname();  
console.log(hostname);
```

--------------------------------

### filesystem.createDirectory

Source: https://neutralino.js.org/docs/api/filesystem

Creates a directory or multiple directories recursively. Throws NE_FS_DIRCRER if directory creation is not possible.

```APIDOC
## filesystem.createDirectory(path)

### Description
Creates a directory or multiple directories recursively. Throws `NE_FS_DIRCRER` if directory creation is not possible.

### Parameters
#### Path Parameters
- **path** (String) - Required - New directory path.

### Request Example
```javascript
await Neutralino.filesystem.createDirectory('./newDirectory');
await Neutralino.filesystem.createDirectory(NL_PATH + '/myFolder/api/fs');
```
```

--------------------------------

### filesystem.readFile

Source: https://neutralino.js.org/docs/api/filesystem

Reads the content of a text file. Supports optional parameters to specify the starting position and the number of bytes to read. Throws an error for file read issues.

```APIDOC
## filesystem.readFile(filename, options)

### Description
Reads a text file. Throws `NE_FS_FILRDER` for file read errors.

### Parameters
- **filename** (String): Filename.

### Options
- **pos** (Number, optional): File cursor position in bytes.
- **size** (Number, optional): File reader buffer size in bytes.

### Return
String (awaited): File content.

### Request Example
```javascript
let data = await Neutralino.filesystem.readFile('./myFile.txt');
console.log(`Content: ${data}`);

let data = await Neutralino.filesystem.readFile('./myFile.txt', {
    pos: 2,
    size: 10
});
console.log(`Content: ${data}`);
```
```

--------------------------------

### Get File Statistics

Source: https://neutralino.js.org/docs/api/filesystem

Retrieve statistics for a given file or directory path. This can be used to check for existence, size, type, and timestamps. Throws NE_FS_NOPATHE if the path is invalid or inaccessible.

```javascript
let stats = await Neutralino.filesystem.getStats('./sampleVideo.mp4');  
console.log('Stats:', stats);  
```

--------------------------------

### Access a mounted local file via URL

Source: https://neutralino.js.org/docs/release-notes/framework

Demonstrates the URL structure for accessing files served through the mount configuration.

```text
http://127.0.0.1/app-res/stat.txt  
```

--------------------------------

### Get Window Size Information

Source: https://neutralino.js.org/docs/api/window

Retrieves the current dimensions, minimum and maximum size constraints, and resizability status of the window. This information can be used to dynamically adjust UI elements or behavior.

```javascript
let sizeInfo = await Neutralino.window.getSize();  
  
console.log(sizeInfo);  
```

--------------------------------

### Get Resource File Statistics

Source: https://neutralino.js.org/docs/api/resources

Fetches statistics for a specific resource file or directory, including its size, and whether it's a file or directory. Use this to check for the existence and properties of resources.

```javascript
let stats = await Neutralino.resources.getStats('/resources/icons/myIcon.png');
console.log('Stats:', stats);
```

--------------------------------

### Take Window Snapshot

Source: https://neutralino.js.org/docs/api/window

Captures the current client area of the window (excluding the frame) and saves it as a PNG image file at the specified path. Ensure the path is valid and writable.

```javascript
await Neutralino.window.snapshot(NL_PATH + '/images/window.png');  
```

--------------------------------

### Get Path Parts

Source: https://neutralino.js.org/docs/api/filesystem

Parses a given file path and returns an object containing its individual components such as root name, directory, filename, and extension. This is useful for analyzing and manipulating path strings.

```javascript
let pathParts = await Neutralino.filesystem.getPathParts('./myFolder/myFile.txt');
console.log('Parts:', pathParts);
```

--------------------------------

### Neutralino.os.showFolderDialog

Source: https://neutralino.js.org/docs/api/os

Shows the folder open dialog to select a directory.

```APIDOC
## Neutralino.os.showFolderDialog(title)

### Description
Shows the folder open dialog.

### Parameters
- **title** (String) - Optional - Title of the dialog.
- **options** (Object) - Optional - Configuration options.
  - **defaultPath** (String) - Optional - Initial path displayed by the dialog.

### Return
- **String** (awaited) - The selected folder path.
```

--------------------------------

### Get Relative Path

Source: https://neutralino.js.org/docs/api/filesystem

Calculates the relative path between two given paths. This function operates on path strings and does not require the paths to exist on the file system. The default base path is NL_CWD if not specified.

```javascript
let path = await Neutralino.filesystem.getRelativePath('./myFolder');
console.log(path);

path = await Neutralino.filesystem.getRelativePath('./myFolder', '/home/user');
console.log(path);
```

--------------------------------

### Mount a local directory with Neutralino.server

Source: https://neutralino.js.org/docs/api/server

Use `server.mount` to map a local directory to a resource path. Ensure the target path is a valid directory to avoid errors like NE_FS_NOPATHE or NE_FS_NOTADIR. If the path is already in use, NE_SR_MPINUSE will be thrown.

```javascript
await Neutralino.server.mount('/app-res', NL_PATH + '/app-res');  
await fetch('/app-res/myFile.txt'); // loads NL_PATH + '/app-res/myFile.txt'  
```

--------------------------------

### Neutralino.window.setMainMenu

Source: https://neutralino.js.org/docs/api/window

Creates or updates the main window menu for GNU/Linux and Windows, and the application menu for macOS.

```APIDOC
## window.setMainMenu(menu)

### Description
Creates/updates the main window menu on GNU/Linux and Windows and application menu on macOS.

### Parameters
#### Path Parameters
- **menu** (WindowMenuItem[]): An array of `WindowMenuItem` objects.

##### WindowMenuItem
- `id` (String, optional): A unique identifier for each menu item.
- `text` (String): Label of the menu item. Use `-` (hyphen) character for a menu separator.
- `isDisabled` (Boolean, optional): A boolean flag to disable/enable a specific menu item.
- `isChecked` (Boolean, optional): A boolean flag to mark a specific menu item as selected.
- `menuItems` (WindowMenuItem[]): Submenu for the current menu item.
- `shortcut` (String, optional): Sets a key accelerator on macOS (e.g., `c` for `Command + C`) and only displays the shortcut on GNU/Linux and Windows, e.g., `Ctrl + C`.
- `action` (String, optional): Pre-defined window action for macOS, i.e., `cut:`, `copy:`, `paste:`, etc.

### Request Example
```javascript
const menu = [
  {id: 'file', text: 'File',
    menuItems: [
    {id: 'open', text: 'Open'},
    {text: '-'},
    {id: 'quit', text: 'Quit'},
  ]},
  {id: 'edit', text: 'Edit',
    menuItems: [
    {id: 'cut', text: 'Cut'},
    {id: 'copy', text: 'Copy'},
    {id: 'paste', text: 'Paste'},
  ]}
];

await Neutralino.window.setMainMenu(menu);
await Neutralino.events.on('mainMenuItemClicked', (evt) => {
    console.log('Menu item:', evt.detail);
});
```
```

--------------------------------

### Spawn and control processes with Neutralino.os.spawnProcess

Source: https://neutralino.js.org/docs/api/os

Initiate a background process and handle its output or termination via event listeners.

```javascript
let pingProc = await Neutralino.os.spawnProcess('ping neutralino.js.org');  
  
Neutralino.events.on('spawnedProcess', (evt) => {  
    if(pingProc.id == evt.detail.id) {  
        switch(evt.detail.action) {  
            case 'stdOut':  
                console.log(evt.detail.data);  
                break;  
            case 'stdErr':  
                console.error(evt.detail.data);  
                break;  
            case 'exit':  
                console.log(`Ping process terminated with exit code: ${evt.detail.data}`);  
                break;  
        }  
    }  
});  
```

--------------------------------

### Generate application bundles

Source: https://neutralino.js.org/docs/distribution/overview

Execute the platform-specific shell scripts to generate application bundles in the ./dist folder.

```bash
./build-mac.sh  
```

```bash
./build-win.sh  
```

```bash
./build-linux.sh  
```

--------------------------------

### Create Directory

Source: https://neutralino.js.org/docs/api/filesystem

Creates a new directory or multiple directories recursively. Ensure the path is valid before calling.

```javascript
await Neutralino.filesystem.createDirectory('./newDirectory');
```

```javascript
await Neutralino.filesystem.createDirectory(NL_PATH + '/myFolder/api/fs');
```

--------------------------------

### Update a spawned process

Source: https://neutralino.js.org/docs/api/os

Demonstrates spawning a process, listening for events, and sending data to the process via standard input.

```javascript
let nodeProc = await Neutralino.os.spawnProcess('node');  
  
Neutralino.events.on('spawnedProcess', (evt) => {  
    if(nodeProc.id == evt.detail.id) {  
        switch(evt.detail.action) {  
            case 'stdOut':  
                console.log(evt.detail.data); // 10  
                break;  
            case 'stdErr':  
                console.error(evt.detail.data);  
                break;  
            case 'exit':  
                console.log(`Node.js process terminated with exit code: ${evt.detail.data}`);  
                break;  
        }  
    }  
});  
  
await Neutralino.os.updateSpawnedProcess(nodeProc.id, 'stdIn', 'console.log(5 + 5);');  
await Neutralino.os.updateSpawnedProcess(nodeProc.id, 'stdInEnd');
```

--------------------------------

### Neutralino.os.execCommand(command, options)

Source: https://neutralino.js.org/docs/api/os

Executes a system command and returns the output, exit code, and process ID.

```APIDOC
## Neutralino.os.execCommand(command, options)

### Description
Executes a command and returns the output. This method can run commands in the background or wait for completion.

### Parameters
- **command** (String) - Required - The command that is to be executed.
- **options** (Object) - Optional
  - **background** (Boolean) - Executes the command in background and resolves the Promise immediately.
  - **stdIn** (String) - Standard input as a string.
  - **cwd** (String) - Current working directory.
  - **envs** (Object) - Key-value pairs of environment variables.

### Return Object (awaited)
- **pid** (Number) - Process identifier.
- **stdOut** (String) - Standard output.
- **stdErr** (String) - Standard error.
- **exitCode** (Number) - Exit code of the process.
```

--------------------------------

### neu build

Source: https://neutralino.js.org/docs/cli/neu-cli

Builds the application by creating the dist folder and producing platform-specific binaries.

```APIDOC
## neu build

### Description
Creates the dist folder and produces binaries for all supported platforms and the resources.neu file.

### Options
- **--release** (flag) - Optional - Creates a portable ZIP file of the application bundle.
- **--embed-resources** (flag) - Optional - Creates a single-file executable by injecting resources.
- **--copy-storage** (flag) - Optional - Copies current Neutralinojs storage to the bundle.
- **--macos-bundle** (flag) - Optional - Creates a minimal MacOS app bundle.
- **--config-file** (string) - Optional - Path to a custom configuration file.
```

--------------------------------

### Set distribution path

Source: https://neutralino.js.org/docs/configuration/neutralino.config.json

Define the directory where built binaries will be stored.

```json
{
    "distributionPath": "/build",
}
```

--------------------------------

### window.snapshot

Source: https://neutralino.js.org/docs/api/window

Captures a screenshot of the current window's client area and saves it as a PNG file.

```APIDOC
## window.snapshot(path)

### Description
Takes a snapshot of the current window client area (without the window frame) and stores as a PNG image file.

### Parameters
* `path` (String): Path where the snapshot PNG file should be stored.

### Example
```javascript
await Neutralino.window.snapshot(NL_PATH + '/images/window.png');
```
```

--------------------------------

### server.getMounts()

Source: https://neutralino.js.org/docs/api/server

Lists all active mount configurations.

```APIDOC
## server.getMounts()

### Description
Lists all active mount configurations.

### Return Object (awaited)
Directory mount map that stores each configuration entry as a key-value pair.

### Request Example
```javascript
let mounts = await Neutralino.server.getMounts();
console.log('Mounts:', mounts);
```
```

--------------------------------

### Build application with embedded resources

Source: https://neutralino.js.org/docs/distribution/overview

Use this command to generate a single self-contained executable that includes all application resources.

```bash
neu build --embed-resources
```

--------------------------------

### window.show

Source: https://neutralino.js.org/docs/api/window

Makes the native window visible if it has been hidden.

```APIDOC
## show

### Description
Shows the native window.

### Method
`Neutralino.window.show()`
```

--------------------------------

### Neutralino.os.spawnProcess(command, options)

Source: https://neutralino.js.org/docs/api/os

Spawns a process in the background and provides an identifier for controlling the process.

```APIDOC
## Neutralino.os.spawnProcess(command, options)

### Description
Spawns a process based on a command in background and lets developers control it.

### Parameters
- **command** (String) - Required - The command that is to be executed in a new process.
- **options** (Object) - Optional
  - **cwd** (String) - Current working directory.
  - **envs** (Object) - Key-value pairs of environment variables.

### Return Object (awaited)
- **id** (Number) - A Neutralino-scoped process identifier used for controlling the process.
- **pid** (Number) - Process identifier from the operating system.
```

--------------------------------

### Build and update the test app client

Source: https://neutralino.js.org/docs/contributing/framework-developer-guide

Updates the test application client using the provided shell script.

```bash
bash ./scripts/update_client.sh  
```

--------------------------------

### Main JavaScript logic

Source: https://neutralino.js.org/docs/getting-started/your-first-neutralinojs-app

The core JavaScript for the application, fetching the username and displaying a greeting. It also initializes Neutralinojs and sets up the window close event.

```javascript
let getUsername = async () => {
  const key = NL_OS == 'Windows' ? 'USERNAME' : 'USER';
  let value = '';
  try {
      value = await Neutralino.os.getEnv(key);
  }
  catch(err) {
      console.error(err);
  }
  document.getElementById('name').innerText = `Hello ${value}`;
}

Neutralino.init();
Neutralino.events.on("windowClose", () => {
  Neutralino.app.exit();
});
getUsername();

```

--------------------------------

### Set Window Size and Constraints

Source: https://neutralino.js.org/docs/api/window

Configures the window's dimensions, including initial size, minimum and maximum dimensions, and resizability. Note that width and height must be set as a pair, and min/max dimensions also require corresponding height values.

```javascript
await Neutralino.window.setSize({  
    width: 500,  
    height: 200,  
    maxWidth: 600,  
    maxHeight: 400  
});  
  
await Neutralino.window.setSize({  
    resizable: false  
});  
```

--------------------------------

### neu create <path>

Source: https://neutralino.js.org/docs/cli/neu-cli

Creates a new Neutralinojs application based on a template.

```APIDOC
## neu create <path>

### Description
Creates a new Neutralinojs app based on a template. The basename of the path is used as the application binary name.

### Parameters
- **path** (string) - Required - The directory path where the app will be created.

### Options
- **--template** (string) - Optional - GitHub repository identifier in <account>/<repo> format.
```

--------------------------------

### window.setFullScreen

Source: https://neutralino.js.org/docs/api/window

Enables the full-screen mode for the native window.

```APIDOC
## setFullScreen

### Description
Enables the full screen mode.

### Method
`Neutralino.window.setFullScreen()`
```

--------------------------------

### computer.sendKey(key, state)

Source: https://neutralino.js.org/docs/api/computer

Simulates keyboard input events.

```APIDOC
## computer.sendKey(key, state)

### Description
Simulates a key press, down, or up event. Throws NE_CO_UNLTOSK if keyboard simulation is not implemented or fails.

### Parameters
- **key** (Number) - Platform-specific key code.
- **state** (String) - Optional. Keyboard button state. Accepted values: 'press', 'down', 'up'. Default is 'press'.

### Example
```javascript
await Neutralino.computer.sendKey(38);
```
```

--------------------------------

### Retrieve system folder paths with os.getPath

Source: https://neutralino.js.org/docs/api/os

Fetches platform-specific directory paths like Downloads or Documents. Throws NE_OS_INVKNPT if an invalid folder name is provided.

```javascript
let downloadsPath = await Neutralino.os.getPath('downloads');  
console.log(`Downloads folder: ${downloadsPath}`);  
```

--------------------------------

### Neutralino.computer.getOSInfo()

Source: https://neutralino.js.org/docs/api/computer

Retrieves information about the host operating system.

```APIDOC
## Neutralino.computer.getOSInfo()

### Description
Returns operating system information.

### Return Object (awaited)
- **name** (String) - Operating system name.
- **description** (String) - Operating system description.
- **version** (String) - Version in the <major>.<minor>.<patch>-<build_number> format.

### Example
```javascript
let osInfo = await Neutralino.computer.getOSInfo();
console.log(`OS: ${osInfo.name}`);
```
```

--------------------------------

### window.focus

Source: https://neutralino.js.org/docs/api/window

Brings the native window to the foreground and gives it focus.

```APIDOC
## focus

### Description
Focuses the native window.

### Method
`Neutralino.window.focus()`
```

--------------------------------

### Open URLs in default browser with os.open

Source: https://neutralino.js.org/docs/api/os

Launches the specified URL in the user's default web browser. If the application is already running in a browser, this will open a new tab.

```javascript
Neutralino.os.open('https://neutralino.js.org');  
```

--------------------------------

### Configure Node.js Host Project in Neutralinojs CLI

Source: https://neutralino.js.org/docs/release-notes/cli

Use this configuration to instruct the Neutralinojs CLI to run a Node.js host project. Specify paths for the project and build outputs, along with commands for initialization, development, and building.

```json
"hostProject": {
  "projectPath": "/node-src",
  "buildPath": "/node-src/dist/",
  "initCommand": "npm install",
  "devCommand": "npm start",
  "buildCommand": "npm run build"
}
```

--------------------------------

### Configure Neutralinojs for frontend integration

Source: https://neutralino.js.org/docs/getting-started/using-frontend-libraries

Configuration steps to point Neutralinojs to the frontend build directory and set the application icon.

```bash
rm -rf www  
```

```json
"documentRoot": "/react-src/build/"  
```

```json
  "modes": {  
    "window": {  
      // --- other options  
      "icon": "/react-src/public/logo192.png"  
    }  
  }  
```

--------------------------------

### server.mount(path, target)

Source: https://neutralino.js.org/docs/api/server

Mounts a local directory to be accessible via the static server. It throws NE_FS_NOPATHE and NE_FS_NOTADIR for invalid targets and NE_SR_MPINUSE if the path is already mounted.

```APIDOC
## server.mount(path, target)

### Description
Mounts a local directory to be accessible via the static server.

### Parameters
#### Path Parameters
- **path** (String) - Required - Resource path.
- **target** (String) - Required - A directory in the local filesystem.

### Request Example
```javascript
await Neutralino.server.mount('/app-res', NL_PATH + '/app-res');
await fetch('/app-res/myFile.txt'); // loads NL_PATH + '/app-res/myFile.txt'
```
```

--------------------------------

### window.create

Source: https://neutralino.js.org/docs/api/window

Creates a new native window for a multi-window Neutralino.js application.

```APIDOC
## window.create(url, WindowOptions)

### Description
Creates a native window. You can use this method to create new windows for your multi-window Neutralinojs app. Neutralinojs spawns a new process for each native window. Therefore, the new window works as an isolated app once the window is created. However, you can build communication streams between windows with the storage API.

### Parameters
* `url` (String): URL to be loaded. Eg: `/resources/aboutWindow.html`. Supports loading both local and remote app resources. Local resource paths need to begin with `/`.
* `options` (WindowOptions, optional): An instance of `WindowOptions` type.
```

--------------------------------

### Neutralino.computer.getKernelInfo()

Source: https://neutralino.js.org/docs/api/computer

Retrieves operating system kernel information.

```APIDOC
## Neutralino.computer.getKernelInfo()

### Description
Returns operating system kernel information.

### Return Object (awaited)
- **variant** (String) - Kernel type (e.g., Linux, Darwin, Windows NT).
- **version** (String) - Kernel version in <major>.<minor>.<patch>-<build_number> format.
```
Tokens:
Raw