@velor/remote-mouse 6.4.8

package/server/utils/paths.js

@@ -0,0 +1,10 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export const projectRoot = path.resolve(__dirname, '../..');
+export const publicDir = path.join(projectRoot, 'public');
+export const clientDir = path.join(projectRoot, 'client');
+export const sharedUtilsDir = path.join(projectRoot, 'utils');

package/server/utils/process.js

@@ -0,0 +1,57 @@
+import { exec, execFile, spawn } from 'node:child_process';
+
+export function execFileAsync(command, args = [], options = {}) {
+  const timeout = options.timeout ?? 3000;
+  return new Promise((resolve) => {
+    execFile(command, args, {
+      timeout,
+      env: options.env,
+      maxBuffer: options.maxBuffer,
+    }, (error, stdout = '', stderr = '') => {
+      resolve({
+        ok: !error,
+        stdout: String(stdout),
+        stderr: String(stderr),
+      });
+    });
+  });
+}
+
+export function execShell(command, timeoutMs) {
+  return new Promise((resolve) => {
+    exec(command, { timeout: timeoutMs, maxBuffer: 1024 * 1024 }, (error, stdout = '', stderr = '') => {
+      resolve({
+        ok: !error,
+        stdout: String(stdout).trim(),
+        stderr: String(stderr).trim(),
+      });
+    });
+  });
+}
+
+export function spawnDetached(command, args = []) {
+  return new Promise((resolve) => {
+    try {
+      const child = spawn(command, args, {
+        detached: true,
+        stdio: 'ignore',
+      });
+
+      let settled = false;
+      const done = (value) => {
+        if (!settled) {
+          settled = true;
+          resolve(value);
+        }
+      };
+
+      child.once('error', () => done(false));
+      child.once('spawn', () => {
+        child.unref();
+        done(true);
+      });
+    } catch (_error) {
+      resolve(false);
+    }
+  });
+}

package/server/utils/robot.js

@@ -0,0 +1,11 @@
+export async function loadRobot() {
+  try {
+    const robotModule = await import('@hurdlegroup/robotjs');
+    return robotModule.default || robotModule;
+  } catch (error) {
+    console.error('RobotJS n\'est pas disponible. Installez les dépendances natives puis relancez.');
+    console.error(error.message);
+    throw error;
+  }
+ 
+}

package/server/utils/semver.js

@@ -0,0 +1,33 @@
+export function parseSemver(version) {
+  const normalized = String(version || '').replace(/^v/i, '').trim();
+  const [core] = normalized.split('-');
+  const parts = core.split('.');
+  if (parts.length < 1 || parts.length > 3) {
+    return null;
+  }
+  const nums = parts.map((part) => Number(part));
+  if (nums.some((n) => !Number.isInteger(n) || n < 0)) {
+    return null;
+  }
+  while (nums.length < 3) {
+    nums.push(0);
+  }
+  return nums;
+}
+
+export function isVersionGreater(a, b) {
+  const av = parseSemver(a);
+  const bv = parseSemver(b);
+  if (!av || !bv) {
+    return false;
+  }
+  for (let i = 0; i < 3; i += 1) {
+    if (av[i] > bv[i]) {
+      return true;
+    }
+    if (av[i] < bv[i]) {
+      return false;
+    }
+  }
+  return false;
+}

package/server/utils/truncateText.js

@@ -0,0 +1,7 @@
+export function truncateText(value, max = 220) {
+    const text = String(value || '').trim();
+    if (text.length <= max) {
+        return text;
+    }
+    return `${text.slice(0, max)}...`;
+}

package/utils/createLazy.js

@@ -0,0 +1,13 @@
+export function createLazy(provider) {
+  let hasValue = false;
+  let value;
+
+  return () => {
+    if (!hasValue) {
+      value = provider();
+      hasValue = true;
+    }
+
+    return value;
+  };
+}

package/utils/functional.js

@@ -0,0 +1,48 @@
+export function disableReentrancy(callback, lock = {}) {
+    lock.reentrant = false;
+    return (...args) => {
+        if (!lock.reentrant) {
+            lock.reentrant = true;
+            try {
+                return callback(...args);
+            } finally {
+                lock.reentrant = false;
+            }
+        }
+        return undefined;
+    };
+}
+
+export function createReentrancyDisabler(callback) {
+    const lock = {};
+    return callback => disableReentrancy(callback, lock);
+}
+
+export function disableConcurrentCalls(...functions) {
+    const lock = {};
+    return functions.map(fun => disableReentrancy(fun, lock));
+}
+
+export function createQueuedRecompute(recompute) {
+    let running = false;
+    let pending = false;
+
+    return (...args) => {
+        if (running) {
+            pending = true;
+            return undefined;
+        }
+
+        running = true;
+        try {
+            let result;
+            do {
+                pending = false;
+                result = recompute(...args);
+            } while (pending);
+            return result;
+        } finally {
+            running = false;
+        }
+    };
+}

package/utils/math.js

@@ -0,0 +1,26 @@
+export function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+
+export function distance2D(a, b) {
+  return Math.hypot(a.x - b.x, a.y - b.y);
+}
+
+export function scaleSigned(value, gain) {
+  return Math.sign(value) * Math.abs(value) * gain;
+}
+
+export function applyNonLinearAcceleration(dx, dy, elapsedMs) {
+  const dt = Math.max(elapsedMs, 1);
+  const dist = Math.hypot(dx, dy);
+  const speed = dist / dt; // px/ms
+
+  // Courbe non lineaire: fine precision a basse vitesse, acceleration plus forte quand ca bouge vite.
+  const normalized = clamp(speed / 0.75, 0, 5);
+  const gain = clamp(0.55 + normalized ** 1.65, 0.55, 5.5);
+
+  return {
+    dx: dx * gain,
+    dy: dy * gain,
+  };
+}

package/utils/notificationSettings.js

@@ -0,0 +1,61 @@
+export const NOTIFICATION_TARGET_CLIENT = 'client';
+export const NOTIFICATION_TARGET_HOST = 'host';
+
+export const NOTIFICATION_ID_CLIENT_CONNECTED = 'clientConnected';
+export const NOTIFICATION_ID_CLIENT_DISCONNECTED = 'clientDisconnected';
+export const NOTIFICATION_ID_SESSION_CREATED = 'sessionCreated';
+export const NOTIFICATION_ID_UPDATE_AVAILABLE = 'updateAvailable';
+export const NOTIFICATION_ID_FORCE_UPDATE_CHECK = 'forceUpdateCheck';
+export const NOTIFICATION_ID_UPDATE_INSTALL = 'updateInstall';
+export const NOTIFICATION_ID_QR = 'qr';
+export const NOTIFICATION_ID_SERVER_INFO = 'serverInfo';
+export const NOTIFICATION_ID_SERVICE_RESTARTING = 'serviceRestarting';
+export const NOTIFICATION_ID_SERVICE_RESTARTED = 'serviceRestarted';
+export const NOTIFICATION_ID_QR_OVERLAY = 'qrOverlay';
+export const NOTIFICATION_ID_ENTRY_TOKEN = 'entryToken';
+
+export const NOTIFICATION_EVENT_DEFINITIONS = [
+  { id: NOTIFICATION_ID_CLIENT_CONNECTED, labelKey: 'adminConfig.notification.clientConnected' },
+  { id: NOTIFICATION_ID_CLIENT_DISCONNECTED, labelKey: 'adminConfig.notification.clientDisconnected' },
+  { id: NOTIFICATION_ID_SESSION_CREATED, labelKey: 'adminConfig.notification.sessionCreated' },
+  { id: NOTIFICATION_ID_UPDATE_AVAILABLE, labelKey: 'adminConfig.notification.updateAvailable' },
+  { id: NOTIFICATION_ID_FORCE_UPDATE_CHECK, labelKey: 'adminConfig.notification.forceUpdateCheck' },
+  { id: NOTIFICATION_ID_UPDATE_INSTALL, labelKey: 'adminConfig.notification.updateInstall' },
+  { id: NOTIFICATION_ID_QR, labelKey: 'adminConfig.notification.qr' },
+  { id: NOTIFICATION_ID_SERVER_INFO, labelKey: 'adminConfig.notification.serverInfo' },
+  { id: NOTIFICATION_ID_SERVICE_RESTARTING, labelKey: 'adminConfig.notification.serviceRestarting' },
+  { id: NOTIFICATION_ID_SERVICE_RESTARTED, labelKey: 'adminConfig.notification.serviceRestarted' },
+  { id: NOTIFICATION_ID_QR_OVERLAY, labelKey: 'adminConfig.notification.qrOverlay' },
+  { id: NOTIFICATION_ID_ENTRY_TOKEN, labelKey: 'adminConfig.notification.entryToken' },
+];
+
+export function getNotificationTargetPath(notificationId, target) {
+  return `notifications.${notificationId}.${target}`;
+}
+
+export function getNotificationPaths() {
+  return NOTIFICATION_EVENT_DEFINITIONS.flatMap(({ id }) => [
+    getNotificationTargetPath(id, NOTIFICATION_TARGET_HOST),
+    getNotificationTargetPath(id, NOTIFICATION_TARGET_CLIENT),
+  ]);
+}
+
+export function createDefaultNotificationSettings(defaultValue = true) {
+  return Object.fromEntries(
+    NOTIFICATION_EVENT_DEFINITIONS.map(({ id }) => [
+      id,
+      {
+        [NOTIFICATION_TARGET_HOST]: defaultValue,
+        [NOTIFICATION_TARGET_CLIENT]: defaultValue,
+      },
+    ]),
+  );
+}
+
+export function isNotificationTargetEnabled(notificationsConfig, notificationId, target) {
+  if (!notificationId || !target) {
+    return true;
+  }
+
+  return Boolean(notificationsConfig?.[notificationId]?.[target]);
+}

package/utils/object.utils.js

@@ -0,0 +1,79 @@
+export function isPlainObject(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+export function setNestedValue(target, dottedPath, value) {
+    const segments = String(dottedPath || '').split('.').filter(Boolean);
+    if (!segments.length) {
+        return;
+    }
+
+    let cursor = target;
+    for (let index = 0; index < segments.length - 1; index += 1) {
+        const segment = segments[index];
+        if (!isPlainObject(cursor[segment])) {
+            cursor[segment] = {};
+        }
+        cursor = cursor[segment];
+    }
+
+    cursor[segments[segments.length - 1]] = value;
+}
+
+export function toFlatMap(value, prefix = '', target = new Map()) {
+    if (!isPlainObject(value)) {
+        if (prefix) {
+            target.set(prefix, value);
+        }
+        return target;
+    }
+
+    for (const [key, nestedValue] of Object.entries(value)) {
+        const nextPrefix = prefix ? `${prefix}.${key}` : key;
+        if (isPlainObject(nestedValue)) {
+            toFlatMap(nestedValue, nextPrefix, target);
+        } else {
+            target.set(nextPrefix, nestedValue);
+        }
+    }
+
+    return target;
+}
+
+export function deepMerge(base, override) {
+    if (!override || typeof override !== 'object' || Array.isArray(override)) {
+        return base;
+    }
+
+    const result = Array.isArray(base) ? [...base] : {...base};
+    for (const [key, value] of Object.entries(override)) {
+        const current = result[key];
+        if (
+            current
+            && typeof current === 'object'
+            && !Array.isArray(current)
+            && value
+            && typeof value === 'object'
+            && !Array.isArray(value)
+        ) {
+            result[key] = deepMerge(current, value);
+        } else if (value !== undefined && value !== null && value !== ''){
+            result[key] = value;
+        }
+    }
+    return result;
+}
+
+export function compactObject(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return value;
+    }
+
+    const compacted = Object.fromEntries(
+        Object.entries(value)
+            .map(([key, nestedValue]) => [key, compactObject(nestedValue)])
+            .filter(([, nestedValue]) => nestedValue !== undefined)
+    );
+
+    return Object.keys(compacted).length ? compacted : undefined;
+}

package/utils/predicates.js

@@ -0,0 +1,17 @@
+export function createExactMatchPredicate(filters = {}) {
+  const entries = Object.entries(filters);
+  if (!entries.length) {
+    return () => true;
+  }
+
+  return (value) => entries.every(([key, expected]) => value?.[key] === expected);
+}
+
+export async function findFirstAvailable(items = [], tester = async () => false) {
+    for (const item of items) {
+        if (await tester(item)) {
+            return item;
+        }
+    }
+    return '';
+}

package/utils/remoteCommands.js

@@ -0,0 +1,40 @@
+export const REMOTE_EVENT_MOUSE_MOVE = 'mouse:move';
+export const REMOTE_EVENT_MOUSE_CLICK = 'mouse:click';
+export const REMOTE_EVENT_MOUSE_BUTTON = 'mouse:button';
+export const REMOTE_EVENT_MOUSE_SCROLL = 'mouse:scroll';
+
+export const REMOTE_EVENT_KEYBOARD_TEXT = 'keyboard:text';
+export const REMOTE_EVENT_KEYBOARD_KEY = 'keyboard:key';
+
+export const REMOTE_EVENT_PREVIEW_START = 'preview:start';
+export const REMOTE_EVENT_PREVIEW_STOP = 'preview:stop';
+export const REMOTE_EVENT_SYSTEM_RELOAD = 'system:reload';
+
+export const REMOTE_EVENT_BROWSER_OPEN = 'browser:open';
+export const REMOTE_EVENT_VLC_OPEN = 'vlc:open';
+export const REMOTE_EVENT_VLC_COMMAND = 'vlc:command';
+export const REMOTE_EVENT_VLC_WINDOW_TOGGLE = 'vlc:window-toggle';
+export const REMOTE_EVENT_VLC_WINDOW_CLOSE = 'vlc:window-close';
+export const REMOTE_EVENT_WINDOW_TOGGLE_MAXIMIZE = 'window:toggle-maximize';
+export const REMOTE_EVENT_WINDOW_CLOSE = 'window:close';
+
+export const REMOTE_EVENT_SAMSUNG_ON = 'samsung:on';
+export const REMOTE_EVENT_SAMSUNG_OFF = 'samsung:off';
+export const REMOTE_EVENT_SAMSUNG_VOL_UP = 'samsung:volup';
+export const REMOTE_EVENT_SAMSUNG_VOL_DOWN = 'samsung:voldown';
+export const REMOTE_EVENT_SAMSUNG_MUTE = 'samsung:mute';
+export const REMOTE_EVENT_SAMSUNG_INPUT = 'samsung:input';
+export const REMOTE_EVENT_SAMSUNG_ENTER = 'samsung:enter';
+export const REMOTE_EVENT_SAMSUNG_PC_INPUT = 'samsung:pc-input';
+
+export const REMOTE_EVENT_ADMIN_PREFIX = 'admin:';
+export const REMOTE_EVENT_ADMIN_RESULT = 'admin:result';
+export const REMOTE_EVENT_ADMIN_UPDATE_CHECK = 'admin:update-check';
+export const REMOTE_EVENT_ADMIN_UPDATE_INSTALL = 'admin:update-install';
+export const REMOTE_EVENT_ADMIN_SERVICE_RESTART = 'admin:service-restart';
+export const REMOTE_EVENT_ADMIN_OPEN_QR_BROWSER_SERVER = 'admin:open-qr-browser-server';
+export const REMOTE_EVENT_ADMIN_OPEN_QR_BROWSER_CLIENT = 'admin:open-qr-browser-client';
+export const REMOTE_EVENT_ADMIN_OPEN_SERVER_INFO_BROWSER_SERVER = 'admin:open-server-info-browser-server';
+export const REMOTE_EVENT_ADMIN_OPEN_SERVER_INFO_BROWSER_CLIENT = 'admin:open-server-info-browser-client';
+export const REMOTE_EVENT_ADMIN_ROTATE_ENTRY_TOKEN = 'admin:rotate-entry-token';
+export const REMOTE_EVENT_ADMIN_TOGGLE_QR_OVERLAY = 'admin:toggle-qr-overlay';

package/utils/sync.js

@@ -0,0 +1,3 @@
+export function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}