@ircam/comote-helpers 0.3.3 → 1.0.1

package/max/CoMote/source/comote-connect/server.js

@@ -0,0 +1,193 @@
+import http from 'node:http';
+import fs from 'node:fs';
+import url from 'node:url';
+import path from 'node:path';
+
+import Max from 'max-api';
+import { WebSocketServer } from 'ws';
+import portfinder from 'portfinder';
+
+import { getWifiInfos } from '@ircam/comote-helpers/wifi-infos.js';
+import { getNetworkInterfacesInfos } from '@ircam/comote-helpers/network-infos.js';
+
+const comoteConfig = {
+  id: 0,
+  interval: 16, // period in ms
+  ws: null,
+  osc: {
+    port: 8001,
+    hostname: '',
+    autostart: true,
+  },
+  webview: '',
+};
+
+const server = http.createServer((req, res) => {
+  const parsedUrl = url.parse(req.url);
+  let pathname = `./comote-connect-public${parsedUrl.pathname}`;
+  const ext = path.parse(pathname).ext || '.html';
+  // maps file extension to MIME typere
+  const map = {
+    '.ico': 'image/x-icon',
+    '.html': 'text/html',
+    '.js': 'text/javascript',
+    '.json': 'application/json',
+    '.css': 'text/css',
+  };
+
+  if (fs.existsSync(pathname)) {
+    // if is a directory search for index file matching the extension
+    if (fs.statSync(pathname).isDirectory()) {
+      pathname += 'index.html';
+    }
+
+    // read file from file system
+    fs.readFile(pathname, (err, data) => {
+      if (err) {
+        res.statusCode = 500;
+        res.end(`Error getting the file: ${err}.`);
+      } else {
+        // if the file is found, set Content-type and send data
+        res.setHeader('Content-type', map[ext] || 'text/plain' );
+        res.end(data);
+      }
+    });
+  } else {
+    // file is not found, return 404
+    res.statusCode = 404;
+    res.end(`File ${pathname} not found!`);
+  }
+});;
+
+console.log('server started');
+
+const wss = new WebSocketServer({ server });
+const sockets = new Set();
+
+wss.on('connection', async function connection(ws) {
+  const wifiInfos = await getWifiInfos();
+  const networkInterfacesInfos = await getNetworkInterfacesInfos();
+
+  const networkInfos = networkInterfacesInfos
+        .sort( (a, b) => {
+          if (a.default) {
+            // default is before
+            return -1;
+          } else if (b.default) {
+            // other is before
+            return 1;
+          } else {
+            // finally, sort by interface name
+            return a.ifaceName < b.ifaceName;
+          }
+
+        });
+  ws.send(JSON.stringify({ type: 'networkInfos', payload: networkInfos }));
+
+  // use first network interface, it should be the default one
+  if (networkInfos && networkInfos[0]) {
+    comoteConfig.osc.hostname  = networkInfos[0].ip4;
+  }
+
+
+  ws.send(JSON.stringify({ type: 'wifiInfos', payload: wifiInfos }));
+  ws.send(JSON.stringify({ type: 'comoteConfig', payload: comoteConfig }));
+
+  sockets.add(ws);
+
+  ws.on('message', async (data, isBinary) => {
+    // isBinary is not always set
+    const message = (isBinary || typeof data !== 'string')
+          ? data.toString()
+          : data;
+
+    const { type, payload } = JSON.parse(message);
+
+    switch (type) {
+      case 'comoteConfig':
+        Object.assign(comoteConfig, payload);
+        ws.send(JSON.stringify({ type: 'comoteConfig', payload: comoteConfig }));
+
+        await Max.outlet('id', comoteConfig.id);
+        await Max.outlet('interval', comoteConfig.interval);
+        await Max.outlet('osc_hostname', comoteConfig.osc.hostname);
+        await Max.outlet('osc_port', comoteConfig.osc.port);
+        await Max.outlet('osc_autostart', comoteConfig.osc.autostart);
+        await Max.outlet('webview_url', comoteConfig.webview);
+        break;
+
+      default:
+        console.warn('received unknown message', {type, payload});
+      break;
+    }
+  });
+
+
+  ws.on('close', () => {
+    sockets.delete(ws);
+  });
+});
+
+const handlers = {
+  id: id => {
+    comoteConfig.id = id;
+    sockets.forEach(ws => {
+      ws.send(JSON.stringify({ type: 'comoteConfig', payload: comoteConfig }));
+    });
+    Max.outlet('id', id);
+  },
+  interval: interval => {
+    comoteConfig.interval = interval;
+    sockets.forEach(ws => {
+      ws.send(JSON.stringify({ type: 'comoteConfig', payload: comoteConfig }));
+    });
+    Max.outlet('interval', interval);
+  },
+  osc_hostname: hostname => {
+    comoteConfig.osc.hostname = hostname;
+    sockets.forEach(ws => {
+      ws.send(JSON.stringify({ type: 'comoteConfig', payload: comoteConfig }));
+    });
+    Max.outlet('osc_hostname', hostname);
+  },
+  osc_port: port => {
+    comoteConfig.osc.port = port;
+    sockets.forEach(ws => {
+      ws.send(JSON.stringify({ type: 'comoteConfig', payload: comoteConfig }));
+    });
+    Max.outlet('osc_port', port);
+  },
+  osc_autostart: autostart => {
+    comoteConfig.osc.autostart = !!autostart;
+    sockets.forEach(ws => {
+      ws.send(JSON.stringify({ type: 'comoteConfig', payload: comoteConfig }));
+    });
+    Max.outlet('osc_autostart', autostart);
+  },
+  webview_url: url => {
+    comoteConfig.webview = url;
+    sockets.forEach(ws => {
+      ws.send(JSON.stringify({ type: 'comoteConfig', payload: comoteConfig }));
+    });
+    Max.outlet('webview_url', url);
+  },
+  bang: async () => {
+    await Max.outlet('id', comoteConfig.id);
+    await Max.outlet('interval', comoteConfig.interval);
+    await Max.outlet('osc_hostname', comoteConfig.osc.hostname);
+    await Max.outlet('osc_port', comoteConfig.osc.port);
+    await Max.outlet('osc_autostart', comoteConfig.osc.autostart);
+    await Max.outlet('webview_url', comoteConfig.webview);
+  }
+};
+
+Max.addHandlers(handlers);
+
+portfinder.basePort = 8888;
+portfinder.getPort((err, port) => {
+  server.listen(port, () => {
+    const url = `http://127.0.0.1:${port}`;
+    console.log(`server listening on ${url}`);
+    Max.outlet('url', url);
+  });
+});

package/max-update.bash

@@ -0,0 +1,44 @@
+#!/bin/bash
+
+cd "$(dirname "$0")" || exit 0
+
+local_path="$(pwd)"
+
+max_examples=(
+  "simple-webview"
+  "soundworks"
+)
+
+exclude_files=(
+  "node_modules"
+  ".build"
+  ".git"
+  ".data"
+  ".vendors"
+)
+
+exclude_options=()
+for x in "${exclude_files[@]}"; do
+  exclude_options+=("--exclude=${x}")
+done
+
+examples_root_path="${local_path}/examples"
+examples_max_path="${local_path}/max/CoMote/examples"
+
+for example in "${max_examples[@]}"; do
+  example_source="${examples_root_path}/${example}"
+  echo "Updating ${example_source}"
+  (
+    cd -- "${example_source}" || {
+      echo "Failed to change directory to ${example_source}"
+      exit 1
+    }
+    npm install
+    npm run build
+    example_destination="${examples_max_path}/${example}"
+    echo "Copying to ${example_destination}"
+    mkdir -p -- "${example_destination}"
+    tar c . | tar xv "${exclude_options[@]}" -C "${example_destination}"
+
+  )
+done

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@ircam/comote-helpers",
-  "version": "0.3.3",
-  "description": "Server component & utilities for the CoMo.te application",
+  "version": "1.0.1",
+  "description": "Server component & utilities for the CoMote application",
   "authors": [
     "Benjamin.Matuszewski@ircam.fr",
     "Jean-Philippe.Lambert@ircam.fr"
   ],
   "license": "BSD-3-Clause",
+  "type": "module",
   "repository": {
     "type": "git",
     "url": "https://github.com/ircam-ismm/comote-helpers"
@@ -14,32 +15,12 @@
   "publishConfig": {
     "access": "public"
   },
-  "scripts": {
-    "api": "jsdoc-to-readme --src src/server.js src/qrcode.js --heading-depth 4",
-    "build": "npm run clean && babel src --out-dir .",
-    "clean": "rm -f server.js qrcode.js",
-    "dev": "npm run build && chokidar src -c \"npm run build\"",
-    "doc": "npm run api && npm run toc",
-    "prepublishOnly": "npm run build",
-    "toc": "markdown-toc -i README.md  --maxdepth 3"
+  "exports": {
+    "./*.js": "./src/*.js"
   },
-  "dependencies": {
-    "assign-deep": "^1.0.1",
-    "clone-deep": "^4.0.1",
-    "debug": "^4.3.1",
-    "node-osc": "^7.0.0",
-    "qrcode": "^1.5.0",
-    "systeminformation": "^5.11.15",
-    "utf-8-validate": "^5.0.9",
-    "ws": "^8.6.0"
-  },
-  "devDependencies": {
-    "@babel/cli": "^7.4.4",
-    "@babel/core": "^7.4.5",
-    "@babel/preset-env": "^7.14.7",
-    "chokidar": "^3.0.1",
-    "chokidar-cli": "^2.1.0",
-    "jsdoc-to-readme": "^1.0.2",
-    "markdown-toc": "^1.2.0"
-  }
+  "workspaces": [
+    ".",
+    "examples/*",
+    "max/CoMote/sources/*"
+  ]
 }

package/src/.editorbackup/network-infos.js~

@@ -0,0 +1,60 @@
+import si from 'systeminformation';
+
+/**
+ * @typedef {Object} NetworkInterfaces
+ * @property {Array.<NetworkInterface>} Interfaces
+ */
+
+/**
+ * @typedef {Object} NetworkInterface
+ *
+ * @property {string} iface: - identifier eg. 'en0'
+ * @property {string} ifaceName - name eg. 'en0'
+ * @property {boolean} default - true if default interface (for sending data)
+ * @property {string} ip4 - address eg. '192.168.0.1'
+ * @property {string} ip4subnet - eg. '255.255.252.0'
+ * @property {string} ip6 eg. 'fe80::456:7890:abcd:ef01'
+ * @property {string} ip6subnet eg. 'ffff:ffff:ffff:ffff::'
+ * @property {string} type eg. 'wireless' or 'wired'
+ *
+ * @see https://www.npmjs.com/package/systeminformation
+ */
+
+/**
+ * Retrieve information of network interfaces
+ *  Return `null` if no WiFi connection found.
+ *
+ * @async
+ * @return {NetworkInterfaces|null}
+ */
+export async function getNetworkInterfacesInfos({
+  interfaceFilter = (i) => {
+    // only IPv4
+    // avoid localhost
+    return i.ip4
+      && i.ip4 !== '127.0.0.1'
+      && i.ip4 !== 'localhost';
+  }
+}= {}) {
+  const interfaces = await si.networkInterfaces();
+
+  if(!interfaces) {
+    return null;
+  }
+
+  if(typeof interfaceFilter !== 'function') {
+    return interfaces;
+  }
+
+  return interfaces.filter(interfaceFilter);
+}
+
+
+
+
+
+
+
+
+
+

package/src/.editorbackup/wifi-infos.js~

@@ -0,0 +1,33 @@
+import si from 'systeminformation';
+
+/**
+ * @typedef {Object} WifiInfos
+ * @property {number} ssid - SSID of the WiFi connection
+ * @property {number} ip - Related IP (IPV4)
+ */
+
+/**
+ * Retrieve the SSID and related IP of the first WiFi connection found, return
+ * `null` if no WiFi connection found.
+ *
+ * @async
+ * @return {WiFiInfos|null}
+ */
+export async function getWifiInfos() {
+  // find first wifi connection
+  const wifiConnections = await si.wifiConnections();
+  const conn = wifiConnections[0];
+
+  if (!conn) {
+    return null;
+  }
+
+  // find related interface
+  const interfaces = await si.networkInterfaces();
+  const int = interfaces.find(int => int.iface === conn.iface);
+
+  return {
+    ssid: conn.ssid,
+    ip: int.ip4,
+  };
+}

package/{network-infos.js → src/network-infos.js}

@@ -1,11 +1,5 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.getNetworkInterfacesInfos = getNetworkInterfacesInfos;
-var _systeminformation = _interopRequireDefault(require("systeminformation"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+import si from 'systeminformation';
+
 /**
  * @typedef {Object} NetworkInterfaces
  * @property {Array.<NetworkInterface>} Interfaces
@@ -40,19 +34,34 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  * @param {interfacaFilterCallback} options.interfaceFilter callback for filter to test interface
  * @return {NetworkInterfaces|null} null if no interface found
  */
-async function getNetworkInterfacesInfos({
-  interfaceFilter = i => {
+export async function getNetworkInterfacesInfos({
+  interfaceFilter = (i) => {
     // only IPv4
     // avoid localhost
-    return i.ip4 && i.ip4 !== '127.0.0.1' && i.ip4 !== 'localhost';
+    return i.ip4
+      && i.ip4 !== '127.0.0.1'
+      && i.ip4 !== 'localhost';
   }
-} = {}) {
-  const interfaces = await _systeminformation.default.networkInterfaces();
-  if (!interfaces) {
+}= {}) {
+  const interfaces = await si.networkInterfaces();
+
+  if(!interfaces) {
     return null;
   }
-  if (typeof interfaceFilter !== 'function') {
+
+  if(typeof interfaceFilter !== 'function') {
     return interfaces;
   }
+
   return interfaces.filter(interfaceFilter);
-}
+}
+
+
+
+
+
+
+
+
+
+

package/{qrcode.js → src/qrcode.js}

@@ -1,44 +1,40 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.dataURL = dataURL;
-exports.rawLink = rawLink;
-exports.terminal = terminal;
-var _qrcode = _interopRequireDefault(require("qrcode"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+import QRCode from 'qrcode';
+
 function formatConfigToLink(config) {
-  let link = `comote://settings?`;
+  let link = `comote://settings?`
   const query = [];
+
   if ('id' in config) {
     query.push(`id=${config.id}`);
   }
+
   if (Number.isFinite(config.interval) && config.interval > 0) {
     query.push(`interval=${config.interval}`);
   }
+
   if (config.ws) {
-    const {
-      protocol,
-      hostname,
-      port,
-      pathname
-    } = config.ws;
+    const { protocol, hostname, port, pathname } = config.ws;
 
     // build valid url
     // only hostname is required
     if (!hostname) {
       throw new Error(`Invalid WebSocket config: ${config.ws}`);
     }
+
     let url = `ws-url=`;
-    url += protocol == 'ws' || protocol == 'wss' ? `${protocol}://` : `ws://`;
+
+    url += (protocol == 'ws' || protocol == 'wss') ? `${protocol}://` : `ws://`;
+
     url += hostname;
+
     if (port) {
       url += `:${port}`;
     }
+
     if (pathname) {
       url += pathname;
     }
+
     query.push(url);
 
     // autostart
@@ -46,27 +42,34 @@ function formatConfigToLink(config) {
       query.push(`ws-enable=1`);
     }
   }
+
   if (config.osc) {
-    const {
-      hostname,
-      port
-    } = config.osc;
+    const { hostname, port } = config.osc;
+
     if (!hostname || !Number.isInteger(port)) {
       throw new Error(`Invalid WebSocket config: ${config.osc}`);
     }
+
     query.push(`osc-url=udp://${hostname}:${port}`);
+
     if (config.osc.autostart === true) {
       query.push(`osc-enable=1`);
     }
   }
+
+  if (config.webview) {
+    query.push(`webview=${encodeURIComponent(config.webview)}`);
+  }
+
   link += query.join('&');
+
   return link;
 }
 
 /**
  * Return the link to be encoded in the QRCode accroding to given `CoMoteConfig`
  */
-function rawLink(config) {
+export function rawLink(config) {
   return formatConfigToLink(config);
 }
 
@@ -77,13 +80,12 @@ function rawLink(config) {
  * @example
  * console(await CoMoteQRCode.terminal(config));
  */
-async function terminal(config) {
+export async function terminal(config) {
   const link = formatConfigToLink(config);
-  return await _qrcode.default.toString(link, {
-    type: 'terminal'
-  });
+  return await QRCode.toString(link, { type: 'terminal', small: true });
 }
 
+
 /**
  * Create a qrcode to be used as in Image source according to given `CoMoteConfig``
  *
@@ -93,7 +95,7 @@ async function terminal(config) {
  *
  * <img src="${qrCode}" />
  */
-async function dataURL(config) {
+ export async function dataURL(config) {
   const link = formatConfigToLink(config);
-  return await await _qrcode.default.toDataURL(link);
-}
+  return await await QRCode.toDataURL(link);
+ }