@genesislcap/pbc-notify-ui 15.8.3 → 15.9.0

package/src/components/foundation-sounds/foundation-sounds.ts

@@ -0,0 +1,222 @@
+import { Connect } from '@genesislcap/foundation-comms';
+import { attr, customElement, GenesisElement, html } from '@genesislcap/web-core';
+import { Subscription } from 'rxjs';
+import { FoundationInboxService, FoundationInboxServiceStore } from '../../services/inbox.service';
+import { RuleService } from '../../services/rule.service';
+import {
+  AlertSoundPlayer,
+  base64ToBlob,
+  getAlertDynamicRuleId,
+  getAlertHeader,
+  getAlertId,
+  getAlertMessage,
+} from '../../utils/alert-sound';
+import { logger } from '../../utils/logger';
+import { AlertStatus } from '../foundation-inbox/inbox.types';
+import { FoundationSoundsStyles } from './foundation-sounds.styles';
+
+/**
+ * Caps the NEW-alert snapshot used to prime known IDs. Realtime inserts are
+ * still prepended by the inbox service after this ceiling.
+ */
+const SOUNDS_MAX_ROWS = 100;
+
+/**
+ * Headless listener for inbox alert inserts. Plays configured sounds via the
+ * shared AlertSoundPlayer. Mount once in the app layout.
+ *
+ * Configure rules in the inbox Sounds tab with {@link FoundationSoundsPanel}.
+ *
+ * @public
+ */
+@customElement({
+  name: 'foundation-sounds',
+  template: html`
+    <slot></slot>
+  `,
+  styles: FoundationSoundsStyles,
+})
+export class FoundationSounds extends GenesisElement {
+  @Connect connect: Connect;
+  @FoundationInboxService inboxService: FoundationInboxService;
+  @RuleService ruleService: RuleService;
+
+  /**
+   * When false, new audible alerts are tracked but do not play.
+   */
+  @attr({ attribute: 'sound-enabled', mode: 'boolean' }) soundEnabled = true;
+
+  private connectionSub?: Subscription;
+  private readonly player = AlertSoundPlayer.shared;
+  private knownAlertIds = new Set<string>();
+  /** In-flight server sound fetches keyed by DYNAMIC_RULE_ID. */
+  private readonly serverSoundFetches = new Map<string, Promise<boolean>>();
+
+  async connectedCallback() {
+    super.connectedCallback();
+
+    await this.player.restore();
+
+    // The await above can outlive this element (mount → unmount → mount, e.g.
+    // via PBCElementsRenderer re-rendering its layout target). Without this
+    // guard we'd wire up a subscription nothing will ever tear down, and a
+    // later mount adds a second one — two overlapping sounds per alert.
+    if (!this.isConnected) {
+      return;
+    }
+
+    this.connectionSub = this.connect.isConnected$.subscribe((isConnected) => {
+      if (isConnected) {
+        this.subscribeToAlerts();
+      }
+    });
+  }
+
+  disconnectedCallback() {
+    super.disconnectedCallback();
+    this.inboxService.unsubscribe(this.subscriptionHandler);
+    this.connectionSub?.unsubscribe();
+    this.connectionSub = undefined;
+  }
+
+  private subscribeToAlerts(): void {
+    this.inboxService.unsubscribe(this.subscriptionHandler);
+    this.knownAlertIds = new Set();
+
+    this.inboxService.subscribe(
+      this.subscriptionHandler,
+      false,
+      `ALERT_STATUS=='${AlertStatus.NEW}'`,
+      SOUNDS_MAX_ROWS,
+      'ALERT_ID,MESSAGE,HEADER,DYNAMIC_RULE_ID',
+    );
+  }
+
+  private subscriptionHandler = ({ store }: { store: FoundationInboxServiceStore }) => {
+    const items = store?.items || [];
+    const current: Array<{
+      id: string;
+      message?: string;
+      header?: string;
+      dynamicRuleId?: string;
+    }> = [];
+
+    for (const item of items) {
+      const id = getAlertId(item);
+      if (!id) {
+        continue;
+      }
+      current.push({
+        id,
+        message: getAlertMessage(item),
+        header: getAlertHeader(item),
+        dynamicRuleId: getAlertDynamicRuleId(item),
+      });
+    }
+
+    // SEQUENCE_ID <= 1 is (part of) the initial snapshot rather than a
+    // real-time update — same boundary as `notification-listener`. A
+    // first-callback latch instead would misfire on a rowless bookkeeping
+    // message (SOURCE_REF/MORE_ROWS only), or if the snapshot itself arrives
+    // split across more than one message.
+    if ((store?.sequenceId ?? 0) <= 1) {
+      for (const row of current) {
+        this.knownAlertIds.add(row.id);
+      }
+      return;
+    }
+
+    if (!this.soundEnabled) {
+      for (const row of current) {
+        this.knownAlertIds.add(row.id);
+      }
+      return;
+    }
+
+    // Collect new rows first so known IDs stay in sync even while async
+    // server-sound fetches run. Play at most once per batch: user Sounds-tab
+    // match first, else server sound on DYNAMIC_RULE_ID — only latch after a
+    // successful play so a failed/in-flight fetch can fall through to later rows.
+    const newRows: typeof current = [];
+    for (const row of current) {
+      if (this.knownAlertIds.has(row.id)) {
+        continue;
+      }
+      this.knownAlertIds.add(row.id);
+      newRows.push(row);
+    }
+    if (newRows.length) {
+      void this.playForNewAlerts(newRows);
+    }
+  };
+
+  private async playForNewAlerts(
+    rows: Array<{
+      id: string;
+      message?: string;
+      header?: string;
+      dynamicRuleId?: string;
+    }>,
+  ): Promise<void> {
+    for (const row of rows) {
+      if (this.player.playForAlert(row)) {
+        return;
+      }
+      if (row.dynamicRuleId && !this.player.isMuted) {
+        // Sequential: stop on first successful play; do not race later rows.
+        // eslint-disable-next-line no-await-in-loop -- try each alert until one sound plays
+        if (await this.tryPlayServerSound(row.dynamicRuleId)) {
+          return;
+        }
+      }
+    }
+  }
+
+  private async tryPlayServerSound(dynamicRuleId: string): Promise<boolean> {
+    const id = dynamicRuleId?.trim();
+    if (!id || this.player.isMuted) {
+      return false;
+    }
+    if (this.player.hasServerSound(id)) {
+      return this.player.playServerSound(id);
+    }
+
+    let fetchPromise = this.serverSoundFetches.get(id);
+    if (!fetchPromise) {
+      fetchPromise = this.fetchAndCacheServerSound(id);
+      this.serverSoundFetches.set(id, fetchPromise);
+      try {
+        return await fetchPromise;
+      } finally {
+        this.serverSoundFetches.delete(id);
+      }
+    }
+    return fetchPromise;
+  }
+
+  private async fetchAndCacheServerSound(dynamicRuleId: string): Promise<boolean> {
+    const sound = await this.ruleService.getAlertSound(dynamicRuleId);
+    if (!sound?.SOUND_DATA) {
+      // Rule may have cleared its sound since we last played — drop stale cache.
+      this.player.clearServerSound(dynamicRuleId);
+      return false;
+    }
+    const mimeType = sound.ALERT_SOUND_MIME_TYPE || 'audio/mpeg';
+    let blob: Blob;
+    try {
+      blob = base64ToBlob(sound.SOUND_DATA, mimeType);
+    } catch (error) {
+      // Malformed base64 must not reject playForNewAlerts — that aborts the
+      // rest of the batch as an unhandled rejection.
+      logger.error(`Invalid alert sound data for rule ${dynamicRuleId}`, error);
+      this.player.clearServerSound(dynamicRuleId);
+      return false;
+    }
+    this.player.setServerSound(dynamicRuleId, {
+      blob,
+      fileName: sound.ALERT_SOUND_FILE_NAME,
+      mimeType,
+    });
+    return this.player.playServerSound(dynamicRuleId);
+  }
+}

package/src/index.ts

@@ -1,7 +1,15 @@
 export * from './components/foundation-inbox/inbox';
 export * from './components/foundation-inbox/components/foundation-inbox-flyout/foundation-inbox-flyout';
 export * from './components/foundation-inbox/components/foundation-inbox-counter/foundation-inbox-counter';
+export * from './components/foundation-sounds/foundation-sounds';
+export * from './components/foundation-sounds/foundation-sounds-panel';
 export * from './components/foundation-notification-dashboard';
+export { AlertSoundPlayer, MAX_SOUND_RULES, MAX_SOUND_FILE_BYTES } from './utils/alert-sound';
+export type {
+  AlertSoundMatchMode,
+  AlertSoundRuleView,
+  AlertSoundSelectableRule,
+} from './utils/alert-sound';
 export type {
   Alert,
   ParameterEditedEventDetail,

package/src/services/inbox.service.ts

@@ -11,6 +11,12 @@ export const INBOX_PAGE_SIZE = 20;
 export interface FoundationInboxServiceStore {
   items: Array<any>;
   moreRows: boolean;
+  /**
+   * SEQUENCE_ID of the last message applied to {@link items}. `<= 1` means the
+   * message was (part of) the initial snapshot rather than a real-time update —
+   * mirrors the boundary `notification-listener` uses (`SEQUENCE_ID > 1`).
+   */
+  sequenceId: number;
 }
 
 export type SubscribeCallback = ({ store }: { store: FoundationInboxServiceStore }) => any;
@@ -51,6 +57,7 @@ class FoundationInboxServiceImpl implements FoundationInboxService {
   public store: FoundationInboxServiceStore = {
     items: [],
     moreRows: false,
+    sequenceId: 0,
   };
 
   private getStream(
@@ -70,6 +77,9 @@ class FoundationInboxServiceImpl implements FoundationInboxService {
         if (result.SOURCE_REF) {
           this.sourceRef = result.SOURCE_REF;
         }
+        if (typeof result.SEQUENCE_ID === 'number') {
+          this.store.sequenceId = result.SEQUENCE_ID;
+        }
         this.store.moreRows = Boolean(result.MORE_ROWS);
         // getMoreRows batches continue the existing order, so append them
         // rather than prepending like real-time inserts.
@@ -127,14 +137,14 @@ class FoundationInboxServiceImpl implements FoundationInboxService {
       const found = this.subscriptions.splice(index, 1);
       found.forEach((subscription) => {
         subscription.socketSubscription.unsubscribe();
-        subscription.callback({ store: { items: [], moreRows: false } });
+        subscription.callback({ store: { items: [], moreRows: false, sequenceId: 0 } });
       });
     }
 
     this.stream = undefined;
     this.sourceRef = null;
     this.fetchingMore = false;
-    this.store = { items: [], moreRows: false };
+    this.store = { items: [], moreRows: false, sequenceId: 0 };
   }
 }
 

package/src/services/rule.service.ts

@@ -1,6 +1,9 @@
 import { Connect, Message } from '@genesislcap/foundation-comms';
 import { DI } from '@genesislcap/web-core';
-import type { Rule } from '../components/foundation-notification-dashboard/components/rules/rule-dialog/rule-dialog.types';
+import type {
+  NotifyAlertSound,
+  Rule,
+} from '../components/foundation-notification-dashboard/components/rules/rule-dialog/rule-dialog.types';
 
 export interface RuleService {
   subscribeRule(dynamicRuleId: string, parameterDetails: any);
@@ -9,6 +12,7 @@ export interface RuleService {
   disableRule(dynamicRuleId: string);
   getRules(): Promise<any>;
   getRuleDetails(ruleId: string): Promise<Rule>;
+  getAlertSound(dynamicRuleId: string): Promise<NotifyAlertSound | null>;
   createRule(rule: Rule): Promise<Message>;
   updateRule(rule: Rule): Promise<Message>;
   deleteRule(ruleId: string): void;
@@ -36,6 +40,38 @@ class RuleServiceImpl implements RuleService {
     return response.REPLY[0];
   }
 
+  async getAlertSound(dynamicRuleId: string): Promise<NotifyAlertSound | null> {
+    if (!dynamicRuleId) {
+      return null;
+    }
+    try {
+      const response = await this.connect.request('REQ_NOTIFY_ALERT_SOUND', {
+        REQUEST: {
+          DYNAMIC_RULE_ID: dynamicRuleId,
+        },
+      });
+      const reply = response?.REPLY;
+      if (!Array.isArray(reply) || !reply.length) {
+        return null;
+      }
+      const row = reply[0] as Record<string, string>;
+      const soundData = row.SOUND_DATA ?? row.soundData;
+      if (!soundData) {
+        return null;
+      }
+      return {
+        ALERT_SOUND_ID: row.ALERT_SOUND_ID ?? row.alertSoundId,
+        DYNAMIC_RULE_ID: row.DYNAMIC_RULE_ID ?? row.dynamicRuleId ?? dynamicRuleId,
+        ALERT_SOUND_FILE_NAME: row.ALERT_SOUND_FILE_NAME ?? row.alertSoundFileName,
+        ALERT_SOUND_MIME_TYPE: row.ALERT_SOUND_MIME_TYPE ?? row.alertSoundMimeType,
+        SOUND_DATA: soundData,
+      };
+    } catch (error) {
+      console.error('Failed to fetch alert sound for rule', dynamicRuleId, error);
+      return null;
+    }
+  }
+
   async createRule(rule: Rule): Promise<Message> {
     return this.connect.commitEvent('EVENT_NOTIFICATION_RULE_CREATE', {
       DETAILS: rule,

package/src/utils/alert-sound.test.ts

@@ -0,0 +1,32 @@
+import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
+import { textContainsWholeWord } from './alert-sound';
+
+const suite = createLogicSuite('alert-sound textContainsWholeWord');
+
+suite('matches a single whole word case-insensitively', () => {
+  assert.ok(textContainsWholeWord('Please trade now', 'trade'));
+  assert.ok(textContainsWholeWord('Please TRADE now', 'trade'));
+  assert.not.ok(textContainsWholeWord('Please trader now', 'trade'));
+});
+
+suite('matches a multi-word phrase', () => {
+  assert.ok(textContainsWholeWord('Risk limit breached today', 'limit breached'));
+  assert.not.ok(textContainsWholeWord('Risk limit breach today', 'limit breached'));
+});
+
+suite('does not match empty or whitespace-only patterns', () => {
+  assert.not.ok(textContainsWholeWord('anything', ''));
+  assert.not.ok(textContainsWholeWord('anything', '   '));
+});
+
+suite('treats short codes as whole words (g1 vs g1h)', () => {
+  assert.ok(textContainsWholeWord('test g1 test', 'g1'));
+  assert.not.ok(textContainsWholeWord('test g1h test', 'g1'));
+});
+
+suite('matches patterns that start or end with punctuation', () => {
+  assert.ok(textContainsWholeWord('cost $100 today', '$100'));
+  assert.ok(textContainsWholeWord('status: FAILED!', 'FAILED!'));
+});
+
+suite.run();