---
title: Node.js
slug: develop/es/nodejs
docTags: 
createdAt: 2025-03-11T07:03:32.131Z
---

Nuestros clientes a menudo necesitan comunicarse entre aplicaciones en un reproductor BrightSign, o entre un reproductor BrightSign y el mundo exterior. Esto se puede hacer utilizando varios protocolos: HTTP, serial y UDP son los más populares. Puede escribir aplicaciones en BrightScript o JavaScript para crear esta funcionalidad. Si elige escribir su aplicación en JavaScript, necesitará Node.js® para implementar funciones como alojar un servidor web en JavaScript.

BrightSign pone a disposición un endpoint de Node.js para que nuestros socios puedan utilizar módulos y funciones de Node.js.

## Implementación de Node.js de BrightSign

Los reproductores BrightSign admiten el entorno de ejecución de Node.js, que se ejecuta sobre el mismo motor JavaScript V8 utilizado por Chromium. Las instancias de Node.js® y Chromium comparten un único contexto de ejecución de JavaScript, por lo que las aplicaciones JavaScript pueden acceder tanto a módulos de Node.js como a objetos DOM al mismo tiempo. El firmware de BrightSign envía eventos de Node.js al bucle de eventos de Chromium, lo que garantiza que las aplicaciones JavaScript reciban eventos de Node.js y DOM sin inconvenientes.

La implementación de Node.js de BrightSign se basa en los proyectos [NW.js](https://github.com/nwjs/nw.js) y [Electron](https://github.com/electron/electron) y comparte muchas características con ellos. Mientras que Electron utiliza un archivo JavaScript como punto de entrada (es decir, el archivo JavaScript crea una webview, que también tiene acceso al entorno de ejecución de Node.js), NW\.js y BrightSign utilizan un archivo HTML como punto de entrada: en un reproductor BrightSign, BrightScript crea una instancia de *roHtmlWidget* habilitada para Node.js; la URL inicial, que se pasa cuando se inicializa *roHtmlWidget*, actúa como el punto de entrada para las aplicaciones Node.js.

Al igual que NW\.js y Electron, BrightSign no utiliza sandboxing. En su lugar, inicia el proceso de renderizado con un usuario y grupo de almacenamiento de Node.js, que tiene permisos de escritura para el almacenamiento local y permisos de lectura para todo el sistema de archivos. También puede acceder a interfaces de red y utilizar puertos privilegiados.

![](https://api.archbee.com/api/optimize/511c8QBH-VHiwWnyzIwUb/TXfd3iBmB-q7V89DT8qqo_nodejscombineddiagrams.png)

La implementación integrada de Node.js en OS 8.2.x y OS 8.3.x se basa en Node v10. Para obtener más documentación e información de uso, consulte la [documentación de la API de Node.js 10.0.0](https://nodejs.org/dist/v10.0.0/docs/api/).

:::hint{type="info"}
Node.js no está habilitado para iframes ni Web Workers.
:::

## Habilitación de Node.js

La funcionalidad de objetos Node.js está disponible en BrightSign Author cuando los usuarios especifican elementos Node.js en [Configuración de la presentación](docId\:a6Ali6u-szxHuansk6T3-). Los objetos Node.js no están disponibles en BrightAuthor Classic.

Node.js se habilita para instancias individuales de *roHtmlWidget* al incluir la entrada `nodejs_enabled:true` en el objeto [roHtmlWidget](docId\:g_TJkqqHLcfT4Fw5_Z6T0).

**Ejemplo:**

```text
r=CreateObject("roRectangle", 0,0,1920,1080)
is = {
	port: 3000
}
config = {
	nodejs_enabled: true
	inspector_server: is
	brightsign_js_objects_enabled: true
	url: "file:///sd:/nodehello.html"
}
h=CreateObject("roHtmlWidget", r, config)
h.Show()
```

:::hint{type="warning"}
No recomendamos cargar sitios web arbitrarios con Node.js habilitado. Algunas bibliotecas JavaScript asumen que Node.js se está ejecutando en una instancia con capacidades del lado del servidor, e intentarán cargar dependencias, lo que provocará que la reproducción falle.
:::

:::hint{type="info"}
Si está utilizando un plugin de BrightSign Author para habilitar Node.js, deberá establecer otros parámetros deseados en el plugin, en lugar de hacerlo con un estado HTML5. Por ejemplo, si desea habilitar el cursor del mouse, deberá establecer `mouse_enabled:true` durante la inicialización de *roHtmlWidget*, en lugar de marcar la casilla en el estado HTML5.
:::

### Seguridad entre dominios

Chromium tiene medidas de seguridad predeterminadas para evitar ataques de cross-site scripting: si la URL de la instancia de *roHtmlWidget* es un dominio remoto, las aplicaciones JavaScript de ese dominio no pueden realizar solicitudes HTTP a otros dominios; por otro lado, si la URL apunta al almacenamiento local, las solicitudes a otros dominios remotos son aceptables.

Si desea hacer referencia a otros dominios en aplicaciones remotas, establezca el parámetro `seguridad web` en `falso` al inicializar *roHtmlWidget*, como se muestra a continuación:

**Ejemplo:**

```text
r=CreateObject("roRectangle", 0,0,1920,1080)
is = {
	port: 3000
}
config = {
	nodejs_enabled: true
	inspector_server: is
	brightsign_js_objects_enabled: true
	url: "http://www.mysitehere.com"
	security_params: {websecurity: false} 
}
h=CreateObject("roHtmlWidget", r, config)
h.Show()
```

### Almacenamiento web

Si desea usar aplicaciones de almacenamiento JavaScript, deberá especificar una `storage_path` y `cuota_de_almacenamiento` al inicializar el *roHtmlWidget*:

**Ejemplo:**

```text
r=CreateObject("roRectangle", 0,0,1920,1080)
is = {
	port: 3000
}
config = {
	nodejs_enabled: true
	inspector_server: is
	brightsign_js_objects_enabled: true
	url: "file:///sd:/nodehello.html"
	storage_path: "SD:"
	storage_quota: 1073741824
}
h=CreateObject("roHtmlWidget", r, config)
h.Show()
```

### JQuery

JQuery® requiere una solución alternativa para funcionar correctamente con Node.js (consulte [esta página](https://stackoverflow.com/questions/4299363/how-to-use-jquery-selectors-in-node-js) para ver un ejemplo). Esta solución alternativa requiere modificar el contenido, por lo que si no tiene control sobre la página web que habilita node en su widget HTML, esto puede causar un problema intratable. Solo debe habilitar Node.js si planea usarlo (por ejemplo, con nuestras [API de JavaScript](docId\:eX9tdDOFF9LZQCYYwr_4j)).

Consulte también [Mejores prácticas de HTML](docId:5sXjTu3N5TGs4ZBRnMysu).

### Node SerialPort

El reproductor BrightSign proporciona enlaces de puerto serie de JavaScript para el paquete Node SerialPort. Estos enlaces pueden utilizarse con la API *@brightsign/serialport*:

```text
const SerialPort = require('@serialport/stream');
const BrightSignBinding = require('@brightsign/serialport');
SerialPort.Binding = BrightSignBinding;
```

Consulte también nuestra [implementación de referencia](https://github.com/brightsign/bs-node-serialport) en GitHub.

### Recarga de aplicaciones web con Node.js habilitado

Cualquier aplicación de cliente que utilice objetos *@brightsign* y algunos de los objetos "BS" arrojará una excepción JavaScript cuando se vuelva a cargar en BrightSignOS 8.0 a 8.4 (aunque puede haber funcionado en OS 7.x y versiones anteriores) debido a limitaciones con módulos nativos en Node 10. Este problema se solucionará en OS 8.5 y versiones posteriores, que incluyen Node 14.x. También puede deshabilitar Node.js (y los objetos *@brightsign*) si no lo necesita.

:::hint{type="warning"}
No se admite la recarga de Node.js mediante Web Inspector o JavaScript.
:::

## Empaquetado y entrega de aplicaciones Node.js

:::hint{type="warning"}
Si está utilizando Electron/Chromium 110 o una versión posterior, BrightSign ya no admite objetos BrightScript/JavaScript en iframes por motivos de seguridad. Las solicitudes de iframes deben enviarse a [parent](https://nam04.safelinks.protection.outlook.com/?url=https%3A%2F%2Fdeveloper.mozilla.org%2Fen-US%2Fdocs%2FWeb%2FAPI%2FWindow%2Fparent\&data=05%7C02%7Csmulqueen%40brightsign.biz%7Cc0b4df4b1a374212f14308dc95fa4ac2%7C8fbcdf641ab847cebdc743e23b04fb3c%7C0%7C0%7C638550149459230214%7CUnknown%7CTWFpbGZsb3d8eyJWIjoiMC4wLjAwMDAiLCJQIjoiV2luMzIiLCJBTiI6Ik1haWwiLCJXVCI6Mn0%3D%7C0%7C%7C%7C\&sdata=%2BBc0ofFac7LaEWddOehvXi7WJyxDFMvLPhPV6YNKl1g%3D\&reserved=0) y luego la página principal debe llamar a objetos BrightSign/JavaScript.
:::

Para implementar su aplicación Node.js en un reproductor BrightSign, ejecute "npm install" en su equipo. Esto creará el directorio `node_modules` . Copie este directorio a la tarjeta SD junto con el resto de la aplicación.

Cuando se inicializa, la implementación de Node.js de BrightSign busca el directorio `node_modules`  relativo al archivo HTML cargado. Al igual que una aplicación estándar de Node.js, luego carga todos los módulos contenidos en el directorio `node_modules` .

Tenga en cuenta que debe actualizar sus módulos Node a versiones compatibles con la [versión correspondiente de Node.js](docId\:YfOH0AmTfIshHW3bE3yKQ) para su OS cuando esté validando su código. Por ejemplo, si está utilizando Chromium 120 (BOS 9.1), debe usar versiones de módulos compatibles con Node.js v18.18.2. El uso de versiones anteriores de los módulos podría provocar un comportamiento inesperado. Como ejemplo, una versión anterior del módulo `descompresor` en BOS 9.1 provocaba que los archivos BrightScript descomprimidos intercambiaran/desordenaran bloques de código.

:::hint{type="info"}
La mayoría de los módulos Node.js contienen únicamente código JavaScript. Sin embargo, algunos módulos contienen código binario. Cuando se instala un módulo que contiene partes binarias mediante "npm install", las partes binarias se compilan para la plataforma local (normalmente Intel x64), y este código no se ejecutará en un reproductor BrightSign. Actualmente, la implementación de Node.js de BrightSign está limitada únicamente a código JavaScript.
:::

### WebPack

El directorio *node\_modules* asociado a una aplicación Node.js puede contener cientos o miles de archivos innecesarios. El empaquetador [webpack](https://webpack.js.org/)® le permite reducir el directorio *node\_modules* a un tamaño manejable.

Para usar webpack®, deberá colocar su función de punto de entrada de Node.js en un archivo separado (p. ej., "index.js"), en lugar de usar HTML en línea. Este archivo contendrá las referencias a otros archivos JavaScript y módulos de Node.js:

**Ejemplo de index.js:**

```text
var myutils = require('./utilities'); // My utilities.js
var moment = require('moment'); // A node module
 
function main() {
 
  myutils.foo();
  moment.now();
  //...
}
```

El archivo JavaScript que contiene el punto de entrada de Node.js puede luego referenciarse en el archivo HTML:

**Ejemplo de HTML:**

```text
<script src='./index.js'></script>
```

Para usar webpack®, adjunte `main()` al objeto window para que pueda encontrarse desde el archivo HTML:

```text
var myutils = require('./utilities'); // My utilities.js
var moment = require('moment'); // A node module
 
function main() {
 
  myutils.foo();
  moment.now();
  //...
}
window.main = main;
```

Cambie el archivo HTML para que apunte al JavaScript empaquetado y a `window.main()`:

```text
<script src='./bundle.js'></script>
 
<body onload="window.main()">
```

Para compilar su bundle, ejecute los siguientes pasos de npm en su computadora:

```text
npm i -D webpack webpack-cli
npx webpack --mode production
```

Ahora puede publicar los archivos index.html y bundle.js; no es necesario publicar el directorio `node_modules` . Consulte el ejemplo de configuración de webpack® a continuación para obtener más información.

::File{src="https://api.archbee.com/api/presign/0prk6SO2dy9LdU77jB8D1/LLOcj1QfrweQkaBLldSXF_webpackconfig.js" label="webpack.config.js" isUploading="false"}

## Rutas de almacenamiento del dispositivo

Para cargar módulos de Node.js y leer/escribir archivos, primero debe definir el directorio raíz del almacenamiento del dispositivo. Los siguientes son directorios raíz comunes:

- microSD: `"storage/sd/"`
- SSD: `"storage/ssd/"`
- USB: `"storage/usb1/"`

Recomendamos usar la llamada `process.chdir()` al comienzo del script para cambiar la ruta del proceso:

**Ejemplo:**

```text
var process = require("process");
process.chdir("/storage/sd");
```

Alternativamente, si tiene módulos ubicados en múltiples unidades de almacenamiento, puede agregar múltiples rutas de búsqueda a un módulo:

**Ejemplo:**

```text
module.paths.push("/storage/sd/")
module.paths.push("/storage/ssd/")
module.paths.push("/storage/usb1/")
```

## Depuración de aplicaciones

Cuando los módulos de Node.js están habilitados, se vuelven visibles desde el [Inspector remoto de Chromium](docId\:TkKeDYusWBEjHd0ljmhCS), lo que le permite depurar aplicaciones. console.log funciona como una aplicación web normal: La salida se redirige tanto a stderr como al inspector remoto.

## Descarga de archivos grandes

Si su aplicación utiliza el objeto XMLHttpRequest para descargar un archivo grande (100-200MB, dependiendo del modelo del reproductor), el reproductor se quedará sin memoria y la operación de descarga fallará. El objeto XMLHttpRequest primero descarga el archivo completo en la memoria, luego crea un objeto blob de igual tamaño, por lo que los requisitos de memoria para una descarga son efectivamente el doble del tamaño del archivo.

Para descargar archivos de varios gigabytes, consulte nuestro ejemplo de [descarga de archivos grandes](https://github.com/brightsign/dev-cookbook/tree/main/examples/browser/large-file-download). La aplicación se define en `index.html` que utiliza streams de Node.js mediante [roHtmlWidget](docId\:g_TJkqqHLcfT4Fw5_Z6T0) para descargar el archivo e incluye un archivo `autorun.brs` que le indica al reproductor que ejecute la aplicación. Más información está disponible en el archivo Readme.md asociado con el ejemplo.&#x20;

## Ejemplos de Node.js

GitHub contiene un [Node.js-starter-project](https://github.com/brightsign/node.js-starter-project). Este proyecto se creó originalmente para BrightAuthor Classic, pero también puede utilizarse con BrightSign Author.

Otro ejemplo es el siguiente script, que inicializa un servidor HTTP en el reproductor BrightSign en el puerto 8000. Cuando un cliente (por ejemplo, un navegador de escritorio) se conecta al servidor, este enviará el número de modelo y la versión de arranque del reproductor al cliente. El script también muestra en la pantalla conectada al reproductor la dirección IP del cliente conectado. 

**Ejemplo:**

```text
<html>
<script>
function displayMessage()
{
  // Load the http module to create an http server.
  var http = require('http');

  // Configure our HTTP server to respond with Hello World to all requests.
  var server = http.createServer(function (request, response) {
    var device_info = new BSDeviceInfo();
    response.writeHead(200, {"Content-Type": "text/plain"});
    response.end("Device Information:\n" + device_info.model + "\n" + device_info.bootVersion + "\n");
    var ip = request.connection.remoteAddress;
    document.getElementById("Ip").innerHTML+="Server responded to: "+ ip + "<br>";
    console.log("Server responded to request from " + ip);
  });

  // Listen on port 8000, IP defaults to 127.0.0.1
  server.listen(8000);

  // Display it on brightsign browser
  var os = require('os');
  var interfaces = os.networkInterfaces();
  var addresses = [];
  for (var k in interfaces) {
      for (var k2 in interfaces[k]) {
          var address = interfaces[k][k2];
          if (address.family === 'IPv4' && !address.internal) {
              addresses.push(address.address);
          }
      }
  }
  var message = "Server running at: " + addresses[0] + ":8000<br>";
  document.getElementById("Ip").innerHTML+= message;

  // Print message on console
  console.log(message);

}
</script>
<body style="background-color:red" onload="displayMessage()">
  <div id = "Ip" style="font-size:60px; text-align:center;">
  </div>
</body>
</html>
```

Los módulos integrados, como "os" y "http", se pueden inicializar mediante el método `require()` . Si la entrada `nodejs_enabled:true` no se incluye al inicializar el objeto *roHtmlWidget* (como se muestra arriba), el método `require()` no estará disponible.
