@genesislcap/pbc-notify-ui 15.8.3 → 15.9.0

package/dist/esm/components/foundation-sounds/foundation-sounds-panel.styles.js

@@ -0,0 +1,200 @@
+import { css } from '@genesislcap/web-core';
+import { scrollbarStyles } from '../../styles/scrollbar.styles';
+export const FoundationSoundsPanelStyles = css `
+  :host {
+    display: flex;
+    flex-direction: column;
+    height: 100%;
+    min-height: 0;
+    width: 100%;
+  }
+
+  .sounds-controls {
+    display: flex;
+    flex-direction: column;
+    flex: 1;
+    min-height: 0;
+    gap: 12px;
+    padding: calc(var(--design-unit) * 3px);
+    box-sizing: border-box;
+  }
+
+  .sounds-help-disclosure {
+    flex: 0 0 auto;
+  }
+
+  .sounds-help-toggle {
+    margin-inline-start: calc(var(--design-unit) * 1px);
+  }
+
+  .sounds-help-toggle::before {
+    content: '+';
+  }
+
+  .sounds-help-disclosure[expanded] .sounds-help-toggle::before {
+    content: '−';
+  }
+
+  .sounds-help {
+    margin: 0;
+    font-size: var(--type-ramp-minus-1-font-size);
+    color: var(--neutral-foreground-hint);
+    text-align: left;
+  }
+
+  .volume-row {
+    display: flex;
+    align-items: center;
+    flex: 0 0 auto;
+    gap: calc(var(--design-unit) * 2px);
+    min-width: 0;
+  }
+
+  .volume-icon {
+    flex: 0 0 auto;
+  }
+
+  .volume-label {
+    flex: 0 0 auto;
+    font-size: var(--type-ramp-minus-1-font-size);
+    color: var(--neutral-foreground-hint);
+  }
+
+  .volume-slider {
+    flex: 1 1 auto;
+    min-width: 0;
+  }
+
+  .volume-percent {
+    flex: 0 0 auto;
+    min-width: 3ch;
+    text-align: end;
+    font-size: var(--type-ramp-minus-1-font-size);
+    color: var(--neutral-foreground-hint);
+  }
+
+  .mute-all {
+    flex: 0 0 auto;
+    margin: 0;
+  }
+
+  .sound-rules-panel {
+    flex: 1 1 auto;
+    min-height: 0;
+    overflow: auto;
+  }
+
+  .sound-rules {
+    display: flex;
+    flex-direction: column;
+    gap: 12px;
+  }
+
+  .sound-rule {
+    display: flex;
+    flex-direction: column;
+    gap: 8px;
+    padding: 12px;
+    border: calc(var(--stroke-width) * 1px) solid var(--neutral-stroke-divider-rest);
+    border-radius: calc(var(--control-corner-radius) * 1px);
+
+    /* Keep absolute listboxes from being clipped by the card itself. */
+    overflow: visible;
+  }
+
+  .sound-rule-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    font-weight: 700;
+    font-size: var(--type-ramp-minus-1-font-size);
+  }
+
+  .sound-rule-actions {
+    display: flex;
+    align-items: center;
+    gap: 2px;
+  }
+
+  .sound-rule-label {
+    display: flex;
+    flex-direction: column;
+    gap: 4px;
+    font-size: var(--type-ramp-minus-1-font-size);
+    color: var(--neutral-foreground-hint);
+  }
+
+  .pattern-input,
+  .match-mode-select,
+  .rule-select,
+  .sound-file-input {
+    width: 100%;
+  }
+
+  /*
+   * Anchor the listbox to the select host and use position:fixed so it escapes
+   * .sound-rules-panel overflow:auto (and the rule card). Each select sets a
+   * unique --sounds-select-anchor / anchor-name via inline style.
+   * !important beats FAST's internal absolute top/bottom for [open] selects.
+   */
+  .match-mode-select[open]::part(listbox),
+  .rule-select[open]::part(listbox) {
+    position: fixed !important;
+    /* stylelint-disable-next-line property-no-unknown -- CSS anchor positioning */
+    position-anchor: var(--sounds-select-anchor);
+    inset: auto !important;
+    top: anchor(bottom) !important;
+    left: anchor(left) !important;
+    right: anchor(right) !important;
+    bottom: auto !important;
+    width: auto !important;
+    margin-top: calc(var(--design-unit) * 1px);
+    z-index: 10000;
+    max-height: min(240px, 40vh);
+    overflow-x: hidden;
+    overflow-y: auto;
+    box-shadow: 0 4px 16px rgb(0 0 0 / 24%);
+  }
+
+  .match-mode-select[open][position='above']::part(listbox),
+  .rule-select[open][position='above']::part(listbox) {
+    top: auto !important;
+    bottom: anchor(top) !important;
+    margin-top: 0;
+    margin-bottom: calc(var(--design-unit) * 1px);
+  }
+
+  .sound-file-row {
+    display: flex;
+    align-items: center;
+    gap: 4px;
+  }
+
+  .sound-file-row .sound-file-input {
+    flex: 1;
+    min-width: 0;
+  }
+
+  .choose-sound {
+    cursor: pointer;
+  }
+
+  .sound-rules-footer {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    flex: 0 0 auto;
+    gap: 8px;
+  }
+
+  .rule-count {
+    font-size: var(--type-ramp-minus-1-font-size);
+    color: var(--neutral-foreground-hint);
+  }
+
+  .file-input {
+    display: none;
+  }
+
+  ${scrollbarStyles}
+`;

package/dist/esm/components/foundation-sounds/foundation-sounds-panel.template.js

@@ -0,0 +1,179 @@
+import { html, ref, repeat } from '@genesislcap/web-core';
+export const FoundationSoundsPanelTemplate = html `
+  <div class="sounds-controls" part="controls">
+    <input
+      ${ref('fileInput')}
+      class="file-input"
+      type="file"
+      accept="audio/*"
+      @change=${(x, c) => x.onFileSelected(c.event)}
+    />
+    <rapid-disclosure class="sounds-help-disclosure" appearance="lightweight">
+      <span slot="title">
+        Sound Alerts Information
+        <span class="sounds-help-toggle" aria-hidden="true"></span>
+      </span>
+      <p class="sounds-help">
+        Add up to ${(x) => x.maxRules} sounds.
+        <br />
+        Match text in MESSAGE or HEADER (a word or phrase), or a notification rule (including rules
+        created when you subscribe to a template).
+        <br />
+        The first matching rule is played.
+      </p>
+    </rapid-disclosure>
+    <div class="volume-row">
+      <rapid-icon
+        class="volume-icon"
+        name=${(x) => (x.muted || x.volumePercent === 0 ? 'volume-xmark' : 'volume-high')}
+      ></rapid-icon>
+      <span class="volume-label">Volume</span>
+      <rapid-slider
+        class="volume-slider"
+        min="0"
+        max="100"
+        step="1"
+        :value=${(x) => String(x.volumePercent)}
+        @change=${(x, c) => x.onVolumeChange(c.event)}
+      ></rapid-slider>
+      <span class="volume-percent">${(x) => `${x.volumePercent}%`}</span>
+      <rapid-button
+        class="mute-all"
+        appearance="lightweight"
+        title=${(x) => (x.muted ? 'Unmute alert sounds' : 'Mute all alert sounds')}
+        @click=${(x) => x.toggleMute()}
+      >
+        ${(x) => (x.muted ? 'Unmute' : 'Mute all')}
+      </rapid-button>
+    </div>
+    <div class="sound-rules-panel">
+      <div class="sound-rules">
+        ${repeat((x) => x.rules, html `
+            <div class="sound-rule" data-rule-index=${(x) => x.index}>
+              <div class="sound-rule-header">
+                <span>Rule ${(x) => x.index + 1}</span>
+                <div class="sound-rule-actions">
+                  <rapid-button
+                    class="mute-rule"
+                    appearance="stealth"
+                    title=${(x) => (x.muted ? 'Unmute this rule' : 'Mute this rule')}
+                    @click=${(x, c) => c.parent.toggleRuleMute(x.index)}
+                  >
+                    <rapid-icon
+                      name=${(x) => (x.muted ? 'volume-xmark' : 'volume-high')}
+                    ></rapid-icon>
+                  </rapid-button>
+                  <rapid-button
+                    class="remove-rule"
+                    appearance="stealth"
+                    title=${(_, c) => (c.parent.canRemoveRule ? 'Remove rule' : 'Reset rule')}
+                    @click=${(x, c) => c.parent.removeRule(x.index)}
+                  >
+                    <rapid-icon name="trash"></rapid-icon>
+                  </rapid-button>
+                </div>
+              </div>
+              <label class="sound-rule-label">
+                Match by
+                <rapid-select
+                  class="match-mode-select"
+                  style=${(x) => `anchor-name: --sound-match-${x.index}; --sounds-select-anchor: --sound-match-${x.index}`}
+                  :value=${(x) => x.matchMode}
+                  @change=${(x, c) => c.parent.onMatchModeChange(x.index, c.event)}
+                >
+                  <rapid-option value="message">MESSAGE text</rapid-option>
+                  <rapid-option value="header">HEADER text</rapid-option>
+                  <rapid-option value="rule">Notification rule</rapid-option>
+                </rapid-select>
+              </label>
+              <label
+                class="sound-rule-label"
+                style=${(x) => (x.matchMode === 'rule' ? 'display: none;' : '')}
+              >
+                ${(x) => (x.matchMode === 'header' ? 'HEADER text' : 'MESSAGE text')}
+                <rapid-text-field
+                  class="pattern-input"
+                  placeholder=${(x) => x.matchMode === 'header' ? 'e.g. Price alert' : 'e.g. limit breached'}
+                  :value=${(x) => x.pattern}
+                  @input=${(x, c) => c.parent.onPatternInput(x.index, c.event)}
+                ></rapid-text-field>
+              </label>
+              <label
+                class="sound-rule-label"
+                style=${(x) => (x.matchMode === 'rule' ? '' : 'display: none;')}
+              >
+                Notification rule
+                <rapid-select
+                  class="rule-select"
+                  style=${(x) => `anchor-name: --sound-rule-${x.index}; --sounds-select-anchor: --sound-rule-${x.index}`}
+                  :value=${(x) => { var _a; return (_a = x.templateId) !== null && _a !== void 0 ? _a : ''; }}
+                  @change=${(x, c) => c.parent.onRuleChange(x.index, c.event)}
+                >
+                  <options-datasource
+                    value-field="id"
+                    label-field="name"
+                    option-element="rapid-option"
+                    :data=${(_, c) => c.parent.ruleSelectOptions}
+                  ></options-datasource>
+                </rapid-select>
+              </label>
+              <label class="sound-rule-label">
+                Sound file
+                <div class="sound-file-row">
+                  <rapid-text-field
+                    class="sound-file-input"
+                    readonly
+                    placeholder="No sound selected"
+                    :value=${(x) => { var _a; return (_a = x.fileName) !== null && _a !== void 0 ? _a : ''; }}
+                    title=${(x) => { var _a; return (_a = x.fileName) !== null && _a !== void 0 ? _a : 'No sound selected'; }}
+                  >
+                    <rapid-icon
+                      slot="end"
+                      class="choose-sound"
+                      name="folder-open"
+                      title="Choose alert sound"
+                      @click=${(x, c) => {
+    c.event.stopPropagation();
+    return c.parent.openFilePicker(x.index);
+}}
+                    ></rapid-icon>
+                  </rapid-text-field>
+                  <rapid-button
+                    class="test-sound"
+                    appearance="stealth"
+                    title="Test play this sound"
+                    ?disabled=${(x) => !x.hasSound}
+                    @click=${(x, c) => c.parent.testSound(x.index)}
+                  >
+                    <rapid-icon name="play"></rapid-icon>
+                  </rapid-button>
+                  <rapid-button
+                    class="clear-sound"
+                    appearance="stealth"
+                    title="Clear sound file"
+                    ?disabled=${(x) => !x.hasSound}
+                    @click=${(x, c) => c.parent.clearSound(x.index)}
+                  >
+                    <rapid-icon name="times"></rapid-icon>
+                  </rapid-button>
+                </div>
+              </label>
+            </div>
+          `)}
+      </div>
+    </div>
+    <div class="sound-rules-footer">
+      <rapid-button
+        class="add-rule"
+        appearance="lightweight"
+        title="Add sound rule"
+        ?disabled=${(x) => !x.canAddRule}
+        @click=${(x) => x.addRule()}
+      >
+        <rapid-icon name="plus"></rapid-icon>
+        Add rule
+      </rapid-button>
+      <span class="rule-count">${(x) => `${x.rules.length} / ${x.maxRules}`}</span>
+    </div>
+  </div>
+`;

package/dist/esm/components/foundation-sounds/foundation-sounds.js

@@ -0,0 +1,206 @@
+import { __awaiter, __decorate } from "tslib";
+import { Connect } from '@genesislcap/foundation-comms';
+import { attr, customElement, GenesisElement, html } from '@genesislcap/web-core';
+import { FoundationInboxService } 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
+ */
+let FoundationSounds = class FoundationSounds extends GenesisElement {
+    constructor() {
+        super(...arguments);
+        /**
+         * When false, new audible alerts are tracked but do not play.
+         */
+        this.soundEnabled = true;
+        this.player = AlertSoundPlayer.shared;
+        this.knownAlertIds = new Set();
+        /** In-flight server sound fetches keyed by DYNAMIC_RULE_ID. */
+        this.serverSoundFetches = new Map();
+        this.subscriptionHandler = ({ store }) => {
+            var _a;
+            const items = (store === null || store === void 0 ? void 0 : store.items) || [];
+            const current = [];
+            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 (((_a = store === null || store === void 0 ? void 0 : store.sequenceId) !== null && _a !== void 0 ? _a : 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 = [];
+            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);
+            }
+        };
+    }
+    connectedCallback() {
+        const _super = Object.create(null, {
+            connectedCallback: { get: () => super.connectedCallback }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            _super.connectedCallback.call(this);
+            yield 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() {
+        var _a;
+        super.disconnectedCallback();
+        this.inboxService.unsubscribe(this.subscriptionHandler);
+        (_a = this.connectionSub) === null || _a === void 0 ? void 0 : _a.unsubscribe();
+        this.connectionSub = undefined;
+    }
+    subscribeToAlerts() {
+        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');
+    }
+    playForNewAlerts(rows) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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 (yield this.tryPlayServerSound(row.dynamicRuleId)) {
+                        return;
+                    }
+                }
+            }
+        });
+    }
+    tryPlayServerSound(dynamicRuleId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const id = dynamicRuleId === null || dynamicRuleId === void 0 ? void 0 : 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 yield fetchPromise;
+                }
+                finally {
+                    this.serverSoundFetches.delete(id);
+                }
+            }
+            return fetchPromise;
+        });
+    }
+    fetchAndCacheServerSound(dynamicRuleId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sound = yield this.ruleService.getAlertSound(dynamicRuleId);
+            if (!(sound === null || sound === void 0 ? void 0 : 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;
+            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);
+        });
+    }
+};
+__decorate([
+    Connect
+], FoundationSounds.prototype, "connect", void 0);
+__decorate([
+    FoundationInboxService
+], FoundationSounds.prototype, "inboxService", void 0);
+__decorate([
+    RuleService
+], FoundationSounds.prototype, "ruleService", void 0);
+__decorate([
+    attr({ attribute: 'sound-enabled', mode: 'boolean' })
+], FoundationSounds.prototype, "soundEnabled", void 0);
+FoundationSounds = __decorate([
+    customElement({
+        name: 'foundation-sounds',
+        template: html `
+    <slot></slot>
+  `,
+        styles: FoundationSoundsStyles,
+    })
+], FoundationSounds);
+export { FoundationSounds };

package/dist/esm/components/foundation-sounds/foundation-sounds.styles.js

@@ -0,0 +1,7 @@
+import { css } from '@genesislcap/web-core';
+/** Headless layout listener — take no space in the layout chrome. */
+export const FoundationSoundsStyles = css `
+  :host {
+    display: none;
+  }
+`;

package/dist/esm/index.js

@@ -1,5 +1,8 @@
 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 { AlertStatus } from './components/foundation-inbox/inbox.types';

package/dist/esm/services/inbox.service.js

@@ -15,6 +15,7 @@ class FoundationInboxServiceImpl {
         this.store = {
             items: [],
             moreRows: false,
+            sequenceId: 0,
         };
     }
     getStream(reverse, criteriaMatch, maxRows, fields) {
@@ -27,6 +28,9 @@ class FoundationInboxServiceImpl {
             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.
@@ -61,13 +65,13 @@ class FoundationInboxServiceImpl {
             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 };
     }
 }
 __decorate([

package/dist/esm/services/rule.service.js

@@ -21,6 +21,41 @@ class RuleServiceImpl {
             return response.REPLY[0];
         });
     }
+    getAlertSound(dynamicRuleId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f;
+            if (!dynamicRuleId) {
+                return null;
+            }
+            try {
+                const response = yield this.connect.request('REQ_NOTIFY_ALERT_SOUND', {
+                    REQUEST: {
+                        DYNAMIC_RULE_ID: dynamicRuleId,
+                    },
+                });
+                const reply = response === null || response === void 0 ? void 0 : response.REPLY;
+                if (!Array.isArray(reply) || !reply.length) {
+                    return null;
+                }
+                const row = reply[0];
+                const soundData = (_a = row.SOUND_DATA) !== null && _a !== void 0 ? _a : row.soundData;
+                if (!soundData) {
+                    return null;
+                }
+                return {
+                    ALERT_SOUND_ID: (_b = row.ALERT_SOUND_ID) !== null && _b !== void 0 ? _b : row.alertSoundId,
+                    DYNAMIC_RULE_ID: (_d = (_c = row.DYNAMIC_RULE_ID) !== null && _c !== void 0 ? _c : row.dynamicRuleId) !== null && _d !== void 0 ? _d : dynamicRuleId,
+                    ALERT_SOUND_FILE_NAME: (_e = row.ALERT_SOUND_FILE_NAME) !== null && _e !== void 0 ? _e : row.alertSoundFileName,
+                    ALERT_SOUND_MIME_TYPE: (_f = row.ALERT_SOUND_MIME_TYPE) !== null && _f !== void 0 ? _f : row.alertSoundMimeType,
+                    SOUND_DATA: soundData,
+                };
+            }
+            catch (error) {
+                console.error('Failed to fetch alert sound for rule', dynamicRuleId, error);
+                return null;
+            }
+        });
+    }
     createRule(rule) {
         return __awaiter(this, void 0, void 0, function* () {
             return this.connect.commitEvent('EVENT_NOTIFICATION_RULE_CREATE', {