@velor/remote-mouse 6.4.8

package/client/services/app-state/createStateStoreService.js

@@ -0,0 +1,64 @@
+import {getStateStoreDefinitions} from './stateDefinitions.js';
+
+function cloneValue(value) {
+  return value && typeof value === 'object' ? structuredClone(value) : value;
+}
+
+export function createStateStoreService() {
+  const state = Object.fromEntries(
+    getStateStoreDefinitions().map(([key, definition]) => [key, cloneValue(definition.defaultValue)]),
+  );
+  const listeners = new Set();
+
+  function notify(key, value, previousValue) {
+    const payload = {
+      key,
+      value: cloneValue(value),
+      previousValue: cloneValue(previousValue),
+      state: getSnapshot(),
+    };
+
+    for (const listener of listeners) {
+      listener(payload);
+    }
+  }
+
+  function get(key) {
+    return cloneValue(state[key]);
+  }
+
+  function getSnapshot() {
+    return Object.fromEntries(
+      Object.entries(state).map(([key, value]) => [key, cloneValue(value)]),
+    );
+  }
+
+  function set(key, value) {
+    const previousValue = state[key];
+    if (Object.is(previousValue, value)) {
+      return value;
+    }
+
+    state[key] = cloneValue(value);
+    notify(key, value, previousValue);
+    return value;
+  }
+
+  function subscribe(listener) {
+    if (typeof listener !== 'function') {
+      return () => {};
+    }
+
+    listeners.add(listener);
+    return () => {
+      listeners.delete(listener);
+    };
+  }
+
+  return {
+    get,
+    getSnapshot,
+    set,
+    subscribe,
+  };
+}

package/client/services/app-state/localStorageBinding.js

@@ -0,0 +1,26 @@
+function safeReadStorage(key) {
+  try {
+    return window.localStorage.getItem(key);
+  } catch (_error) {
+    return '';
+  }
+}
+
+function safeWriteStorage(key, value) {
+  try {
+    window.localStorage.setItem(key, value);
+  } catch (_error) {
+    // Best effort.
+  }
+}
+
+export function createStorageBinding(key) {
+  return {
+    read() {
+      return safeReadStorage(key);
+    },
+    write(value) {
+      safeWriteStorage(key, value);
+    },
+  };
+}

package/client/services/app-state/normalizers.js

@@ -0,0 +1,74 @@
+import {
+  SUPPORTED_HANDEDNESS,
+  SUPPORTED_THEMES,
+} from '../../preferences/constants.js';
+
+export function normalizeString(value, fallback = '') {
+  const normalized = String(value ?? '').trim();
+  return normalized || fallback;
+}
+
+export function normalizeTheme(value) {
+  const normalized = String(value || '').trim().toLowerCase();
+  return SUPPORTED_THEMES.has(normalized) ? normalized : 'dark';
+}
+
+export function normalizeHandedness(value) {
+  const normalized = String(value || '').trim().toLowerCase();
+  return SUPPORTED_HANDEDNESS.has(normalized) ? normalized : 'right';
+}
+
+export function normalizeRemoteAutoHide(value) {
+  if (typeof value === 'boolean') {
+    return value;
+  }
+
+  const normalized = String(value || '').trim().toLowerCase();
+  if (!normalized) {
+    return true;
+  }
+  return !(normalized === 'false' || normalized === '0' || normalized === 'off' || normalized === 'no');
+}
+
+export function normalizeBooleanRecord(value, fallback = {}) {
+  if (value && typeof value === 'object' && !Array.isArray(value)) {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, entryValue]) => [key, Boolean(entryValue)]),
+    );
+  }
+
+  if (!value) {
+    return fallback;
+  }
+
+  try {
+    const parsed = JSON.parse(value);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+      return fallback;
+    }
+
+    return Object.fromEntries(
+      Object.entries(parsed).map(([key, entryValue]) => [key, Boolean(entryValue)]),
+    );
+  } catch (_error) {
+    return fallback;
+  }
+}
+
+export function normalizeRemoteVisibilityState(value) {
+  const nextState = normalizeBooleanRecord(value);
+  if (Object.keys(nextState).length > 0) {
+    return nextState;
+  }
+
+  const normalized = String(value || '').trim().toLowerCase();
+  if (normalized === 'false' || normalized === '0' || normalized === 'off') {
+    return {
+      browser: false,
+      samsung: false,
+      preview: false,
+    };
+  }
+
+  return {};
+}

package/client/services/app-state/resolveEffectiveStateValue.js

@@ -0,0 +1,58 @@
+import {
+  APP_STATE_BROWSER_VISIBILITY,
+  APP_STATE_EFFECTIVE_BROWSER_REMOTE_VISIBLE,
+  APP_STATE_EFFECTIVE_KEYBOARD_REMOTE_VISIBLE,
+  APP_STATE_EFFECTIVE_PREVIEW_REMOTE_VISIBLE,
+  APP_STATE_EFFECTIVE_SAMSUNG_REMOTE_VISIBLE,
+  APP_STATE_EFFECTIVE_VLC_REMOTE_VISIBLE,
+  APP_STATE_REMOTE_VISIBILITY,
+} from './appStateKeys.js';
+
+function getConfigSection(config, section) {
+  return config?.[section] || {};
+}
+
+function getRecordFlag(record, key, fallback = true) {
+  if (record && typeof record === 'object' && Object.hasOwn(record, key)) {
+    return Boolean(record[key]);
+  }
+
+  return Boolean(fallback);
+}
+
+export function resolveEffectiveStateValue(key, {stateStore, persistStore, clientConfig}) {
+  const config = clientConfig.getConfig();
+  const remoteVisibility = persistStore.get(APP_STATE_REMOTE_VISIBILITY);
+  const browserVisibility = persistStore.get(APP_STATE_BROWSER_VISIBILITY);
+
+  switch (key) {
+    case APP_STATE_EFFECTIVE_BROWSER_REMOTE_VISIBLE:
+      return getConfigSection(config, 'browser').enabled !== false
+        && getRecordFlag(remoteVisibility, 'browser', true);
+
+    case APP_STATE_EFFECTIVE_KEYBOARD_REMOTE_VISIBLE:
+      return getConfigSection(config, 'keyboard').enabled !== false
+        && getRecordFlag(remoteVisibility, 'keyboard', true);
+
+    case APP_STATE_EFFECTIVE_VLC_REMOTE_VISIBLE:
+      return getConfigSection(config, 'vlc').enabled !== false
+        && getRecordFlag(remoteVisibility, 'vlc', true);
+
+    case APP_STATE_EFFECTIVE_SAMSUNG_REMOTE_VISIBLE:
+      return getRecordFlag(remoteVisibility, 'samsung', true);
+
+    case APP_STATE_EFFECTIVE_PREVIEW_REMOTE_VISIBLE:
+      return getConfigSection(config, 'preview').enabled !== false
+        && getRecordFlag(remoteVisibility, 'preview', true);
+
+    default:
+      if (key.startsWith('effective.browser.') && key.endsWith('.visible')) {
+        const browserId = key.slice('effective.browser.'.length, -'.visible'.length);
+        const browserConfig = getConfigSection(config, 'browser');
+        return browserConfig.enabled !== false
+          && browserConfig?.[browserId] !== false
+          && getRecordFlag(browserVisibility, browserId, true);
+      }
+      return undefined;
+  }
+}

package/client/services/app-state/stateDefinitions.js

@@ -0,0 +1,107 @@
+import {
+  BROWSER_VISIBILITY_STORAGE_KEY,
+  HANDEDNESS_STORAGE_KEY,
+  REMOTE_AUTO_HIDE_STORAGE_KEY,
+  REMOTE_VISIBILITY_STORAGE_KEY,
+  THEME_STORAGE_KEY,
+} from '../../preferences/constants.js';
+import {LOCALE_STORAGE_KEY} from '../../i18n/constants.js';
+import {resolveLocale} from '../../i18n/core.js';
+import {
+  APP_STATE_BROWSER_VISIBILITY,
+  APP_STATE_HANDEDNESS,
+  APP_STATE_KEYBOARD_PREVIEW_ACTIVE,
+  APP_STATE_LOCALE,
+  APP_STATE_PREVIEW_ACTIVITY_AT,
+  APP_STATE_REMOTE_ACCORDION_EXPANDED_PANEL,
+  APP_STATE_REMOTE_AUTO_HIDE,
+  APP_STATE_REMOTE_VISIBILITY,
+  APP_STATE_THEME,
+} from './appStateKeys.js';
+import {
+  normalizeBooleanRecord,
+  normalizeHandedness,
+  normalizeRemoteAutoHide,
+  normalizeRemoteVisibilityState,
+  normalizeString,
+  normalizeTheme,
+} from './normalizers.js';
+
+export const APP_STATE_STORE_STATE = 'state';
+export const APP_STATE_STORE_PERSIST = 'persist';
+
+export const APP_STATE_DEFINITIONS = {
+  [APP_STATE_PREVIEW_ACTIVITY_AT]: {
+    store: APP_STATE_STORE_STATE,
+    defaultValue: 0,
+    normalize: (value) => Number(value) || 0,
+  },
+  [APP_STATE_KEYBOARD_PREVIEW_ACTIVE]: {
+    store: APP_STATE_STORE_STATE,
+    defaultValue: false,
+    normalize: Boolean,
+  },
+  [APP_STATE_REMOTE_ACCORDION_EXPANDED_PANEL]: {
+    store: APP_STATE_STORE_STATE,
+    defaultValue: '',
+    normalize: (value) => normalizeString(value),
+  },
+  [APP_STATE_THEME]: {
+    store: APP_STATE_STORE_PERSIST,
+    storageKey: THEME_STORAGE_KEY,
+    defaultValue: 'dark',
+    normalize: normalizeTheme,
+    serialize: String,
+  },
+  [APP_STATE_LOCALE]: {
+    store: APP_STATE_STORE_PERSIST,
+    storageKey: LOCALE_STORAGE_KEY,
+    defaultValue: '',
+    normalize: (value) => resolveLocale(
+      value || (typeof navigator !== 'undefined' ? navigator.language : ''),
+    ),
+    serialize: String,
+  },
+  [APP_STATE_HANDEDNESS]: {
+    store: APP_STATE_STORE_PERSIST,
+    storageKey: HANDEDNESS_STORAGE_KEY,
+    defaultValue: 'right',
+    normalize: normalizeHandedness,
+    serialize: String,
+  },
+  [APP_STATE_REMOTE_AUTO_HIDE]: {
+    store: APP_STATE_STORE_PERSIST,
+    storageKey: REMOTE_AUTO_HIDE_STORAGE_KEY,
+    defaultValue: true,
+    normalize: normalizeRemoteAutoHide,
+    serialize: (value) => value ? 'true' : 'false',
+  },
+  [APP_STATE_REMOTE_VISIBILITY]: {
+    store: APP_STATE_STORE_PERSIST,
+    storageKey: REMOTE_VISIBILITY_STORAGE_KEY,
+    defaultValue: {},
+    normalize: normalizeRemoteVisibilityState,
+    serialize: JSON.stringify,
+  },
+  [APP_STATE_BROWSER_VISIBILITY]: {
+    store: APP_STATE_STORE_PERSIST,
+    storageKey: BROWSER_VISIBILITY_STORAGE_KEY,
+    defaultValue: {},
+    normalize: (value) => normalizeBooleanRecord(value),
+    serialize: JSON.stringify,
+  },
+};
+
+export function getAppStateDefinition(key) {
+  return APP_STATE_DEFINITIONS[key] || null;
+}
+
+export function getPersistStateDefinitions() {
+  return Object.entries(APP_STATE_DEFINITIONS)
+    .filter(([, definition]) => definition.store === APP_STATE_STORE_PERSIST);
+}
+
+export function getStateStoreDefinitions() {
+  return Object.entries(APP_STATE_DEFINITIONS)
+    .filter(([, definition]) => definition.store === APP_STATE_STORE_STATE);
+}

package/client/services/backend/createBackendService.js

@@ -0,0 +1,55 @@
+export function createBackendService(services) {
+  async function request(path, options = {}) {
+    const response = await fetch(path, {
+      cache: 'no-store',
+      ...options,
+    });
+
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}`);
+    }
+
+    return response;
+  }
+
+  async function requestJson(path, options = {}) {
+    const response = await request(path, options);
+    return response.json();
+  }
+
+  return {
+    request,
+    requestJson,
+    async getClientConfig() {
+      return requestJson('/api/admin/configs');
+    },
+    async createConfigSubscription(scope = 'config') {
+      return requestJson('/api/admin/subs/configs', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({scope}),
+      });
+    },
+    createEventSource(eventsUrl) {
+      return new EventSource(eventsUrl);
+    },
+    async deleteSubscription(id) {
+      const encodedId = encodeURIComponent(String(id || ''));
+      return fetch(`/api/admin/subs/${encodedId}`, {
+        method: 'DELETE',
+        keepalive: true,
+      });
+    },
+    async getAvailableRemotes() {
+      return requestJson('/api/admin/remotes');
+    },
+    async getAvailableBrowsers() {
+      return requestJson('/api/admin/remotes/browsers');
+    },
+    async getSamsungStatus() {
+      return requestJson('/api/remotes/samsung/status');
+    },
+  };
+}

package/client/services/config/ConfigView.js

@@ -0,0 +1,45 @@
+import {DEFAULT_CLIENT_CONFIG} from './defaultClientConfig.js';
+
+export class ConfigView {
+    #config;
+
+    constructor(config) {
+        this.#config = config || {};
+    }
+
+    #getSection(name, fallback) {
+        return this.#config?.[name] || fallback;
+    }
+
+    getSection(name, fallback) {
+        return this.#getSection(name, fallback);
+    }
+
+    getInputConfig() {
+        return this.#getSection('input', DEFAULT_CLIENT_CONFIG.input);
+    }
+
+    getSamsungConfig() {
+        return this.#getSection('samsungTv', {});
+    }
+
+    getPreviewConfig() {
+        return this.#getSection('preview', DEFAULT_CLIENT_CONFIG.preview);
+    }
+
+    getVlcConfig() {
+        return this.#getSection('vlc', DEFAULT_CLIENT_CONFIG.vlc);
+    }
+
+    getBrowserConfig() {
+        return this.#getSection('browser', DEFAULT_CLIENT_CONFIG.browser);
+    }
+
+    getKeyboardConfig() {
+        return this.#getSection('keyboard', DEFAULT_CLIENT_CONFIG.keyboard);
+    }
+
+    getSystemConfig() {
+        return this.#getSection('system', DEFAULT_CLIENT_CONFIG.system);
+    }
+}

package/client/services/config/createClientConfigService.js

@@ -0,0 +1,122 @@
+import {setNestedValue} from '../../../utils/object.utils.js';
+import {DEFAULT_CLIENT_CONFIG} from './defaultClientConfig.js';
+
+function getConfigObjectFromEntries(entries) {
+    const config = {};
+
+    for (const entry of entries || []) {
+        if (!entry?.id) {
+            continue;
+        }
+
+        setNestedValue(config, entry.id, entry.value);
+    }
+
+    return config;
+}
+
+export function createClientConfigService(services) {
+    let configState = structuredClone(DEFAULT_CLIENT_CONFIG);
+    let subscriptionId = '';
+    let configStream = null;
+    let unloadBound = false;
+    const listeners = new Set();
+
+    function notifyListeners() {
+        for (const listener of listeners) {
+            listener(configState);
+        }
+    }
+
+    function applyConfigEntries(entries = []) {
+        for (const entry of entries) {
+            if (!entry?.path) {
+                continue;
+            }
+
+            setNestedValue(configState, entry.path, entry.value);
+        }
+
+        notifyListeners();
+    }
+
+    async function loadClientConfig() {
+        const payload = await services.getBackend().getClientConfig();
+        const loadedConfig = payload?.config || getConfigObjectFromEntries(payload?.configs);
+        configState = {
+            ...structuredClone(DEFAULT_CLIENT_CONFIG),
+            ...loadedConfig,
+            system: {
+                ...DEFAULT_CLIENT_CONFIG.system,
+                ...payload?.systemConfig,
+            },
+        };
+        notifyListeners();
+    }
+
+    async function subscribeToConfigEvents() {
+        if (typeof window.EventSource !== 'function') {
+            return;
+        }
+
+        const payload = await services.getBackend().createConfigSubscription('config');
+        subscriptionId = String(payload.id || '');
+        if (!subscriptionId || !payload.eventsUrl) {
+            return;
+        }
+
+        configStream?.close();
+        configStream = services.getBackend().createEventSource(payload.eventsUrl);
+        configStream.addEventListener('config.changed', (event) => {
+            try {
+                const data = JSON.parse(event.data || '{}');
+                applyConfigEntries(data.entries);
+            } catch (_error) {
+            }
+        });
+    }
+
+    function unsubscribeFromConfigEvents() {
+        if (!subscriptionId) {
+            return;
+        }
+
+        services.getBackend().deleteSubscription(subscriptionId).catch(() => {
+        });
+        configStream?.close();
+        configStream = null;
+        subscriptionId = '';
+    }
+
+    return {
+        async init() {
+            try {
+                await loadClientConfig();
+            } catch (_error) {
+                configState = structuredClone(DEFAULT_CLIENT_CONFIG);
+            }
+
+            await subscribeToConfigEvents();
+            if (!unloadBound) {
+                window.addEventListener('beforeunload', unsubscribeFromConfigEvents, {once: true});
+                unloadBound = true;
+            }
+
+            return this;
+        },
+        getConfig() {
+            return configState;
+        },
+        onChange(listener) {
+            if (typeof listener !== 'function') {
+                return () => {
+                };
+            }
+
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+    };
+}

package/client/services/config/defaultClientConfig.js

@@ -0,0 +1,22 @@
+export const DEFAULT_CLIENT_CONFIG = {
+  system: {
+    adminActionsEnabled: true,
+  },
+  input: {
+    touchDragHoldMs: 420,
+    touchDragStillDistancePx: 8,
+  },
+  browser: {
+    enabled: true,
+  },
+  keyboard: {
+    enabled: true,
+  },
+  vlc: {
+    enabled: false,
+  },
+  preview: {
+    enabled: true,
+    hideDelayMs: 10000,
+  },
+};

package/client/services/createServicesContainer.js

@@ -0,0 +1,48 @@
+import {createLazy} from '../../utils/createLazy.js';
+import {ConfigView} from './config/ConfigView.js';
+import {APP_STATE_LOCALE} from './app-state/createAppStateService.js';
+
+export async function initializeCoreServices(services) {
+  await services.getClientConfig().init();
+  services.getAppState().init();
+  await services.getI18n().init(services.getAppState().get(APP_STATE_LOCALE));
+  services.getAppState().subscribeProperty(APP_STATE_LOCALE, ({value}) => {
+    services.getI18n().setLocale(value).catch(() => {});
+  });
+  return services;
+}
+
+export function initializeRealtimeServices(services) {
+  services.getTransport().connect();
+  services.getNotifications().bindTransport();
+  return services;
+}
+
+export function createServicesContainer({
+  createI18nService,
+  createClientConfigService,
+  createTransportService,
+  createBackendService,
+  createRemotesService,
+  createPubSubService,
+  createNotificationService,
+  createStateStoreService,
+  createPersistStoreService,
+  createAppStateService,
+}) {
+  const container = {
+    getI18n: createLazy(() => createI18nService(container)),
+    getClientConfig: createLazy(() => createClientConfigService(container)),
+    getConfigView: () => new ConfigView(container.getClientConfig().getConfig()),
+    getTransport: createLazy(() => createTransportService(container)),
+    getBackend: createLazy(() => createBackendService(container)),
+    getRemotes: createLazy(() => createRemotesService(container)),
+    getPubSub: createLazy(() => createPubSubService(container)),
+    getNotifications: createLazy(() => createNotificationService(container)),
+    getStateStore: createLazy(() => createStateStoreService(container)),
+    getPersistStore: createLazy(() => createPersistStoreService(container)),
+    getAppState: createLazy(() => createAppStateService(container)),
+  };
+
+  return container;
+}

package/client/services/createServicesRegistry.js

@@ -0,0 +1,26 @@
+import {createServicesContainer} from './createServicesContainer.js';
+import {createI18nService} from './i18n/createI18nService.js';
+import {createClientConfigService} from './config/createClientConfigService.js';
+import {createSocketIoTransportService} from './transport/createSocketIoTransportService.js';
+import {createBackendService} from './backend/createBackendService.js';
+import {createRemotesService} from './remotes/createRemotesService.js';
+import {createPubSubService} from './pubsub/createPubSubService.js';
+import {createNotificationService} from './notifications/createNotificationService.js';
+import {createAppStateService} from './app-state/createAppStateService.js';
+import {createStateStoreService} from './app-state/createStateStoreService.js';
+import {createPersistStoreService} from './app-state/createPersistStoreService.js';
+
+export function createServicesRegistry() {
+  return createServicesContainer({
+    createI18nService,
+    createClientConfigService,
+    createTransportService: createSocketIoTransportService,
+    createBackendService,
+    createRemotesService,
+    createPubSubService,
+    createNotificationService,
+    createStateStoreService,
+    createPersistStoreService,
+    createAppStateService,
+  });
+}