@qualified-salesforce/web 0.0.1-oidc-bootstrap

package/widget/multimodal_v2/stores/meeting_store.js

@@ -0,0 +1,477 @@
+import { signals_core_module_r, signals_core_module_d, signals_core_module_w } from "../../../js/multimodal_v2.js";
+import { BookerOutcomeTracker, BOOKER_SURFACE, bookerPathwayOrigin } from "../../booker_outcome_tracker.js";
+import { observeBookerOutcome } from "../../form_cta_booker_intent.js";
+import { serverLogger } from "../../server-logger.js";
+import { getNextSlotAfterWeek, formatMonthTitle, findFirstSlotIndexFrom, getDefaultTimeZone, getSameDaySlots, getPrevSlotBeforeWeek, formatTimeShort, buildCalendarDays } from "../components/meetings/utils.js";
+import { $exists, $any, $not } from "../utils/signals.js";
+import { esm_browser_v4 } from "../../../js/4101.js";
+import { validateEmail } from "../../../src/validation.js.js";
+
+
+
+
+
+
+
+
+
+var meeting_store_Step = /*#__PURE__*/ function(Step) {
+    Step["Select"] = "select";
+    Step["Email"] = "email";
+    return Step;
+}({});
+/**
+ * How many time slots a page holds, by the layout the booker is drawing in.
+ *
+ * The grid is three across when the booker is compact and four when it is not, and
+ * the surfaces that draw it full size have a 500px card to fill — five rows of
+ * 36px slots. Paging a wide grid twelve at a time left two of those rows empty and
+ * put a "next" arrow in front of times that would have fitted on screen.
+ */ const PAGE_SIZE = {
+    small: 12,
+    large: 20
+};
+class MeetingStore {
+    // Actions
+    selectTimeSlot(timeSlot) {
+        this.selectedTimeSlot.value = timeSlot;
+    }
+    selectTimeZone(timeZone) {
+        this.timeZone.value = timeZone;
+    }
+    setEmail(email) {
+        signals_core_module_r(()=>{
+            this.email.value = email;
+            this.error.value = null;
+        });
+    }
+    setStep(step) {
+        this.step.value = step;
+    }
+    gotoNextStep() {
+        this.setStep("email");
+    }
+    gotoPrevStep() {
+        this.setStep("select");
+    }
+    navigateToPrevWeek() {
+        this.navigateToWeek(-1);
+    }
+    navigateToNextWeek() {
+        this.navigateToWeek(1);
+    }
+    navigateToPrevPage() {
+        this.navigateToPage(-1);
+    }
+    navigateToNextPage() {
+        this.navigateToPage(1);
+    }
+    selectDate(date) {
+        const index = findFirstSlotIndexFrom(this.sortedSlots.value, date);
+        if (index < this.sortedSlots.value.length) {
+            this.selectTimeSlot(this.sortedSlots.value[index]);
+        }
+    }
+    async confirmBooking() {
+        // Early return if form is not ready
+        if (this.submitDisabled.value) return;
+        const payload = this.buildPayload();
+        if (!payload) return;
+        // Keep reference to the offer message the confirmation is for
+        const offerMessage = this.activeOfferMessage.value;
+        if (!offerMessage) return;
+        try {
+            signals_core_module_r(()=>{
+                this.loading.value = true;
+                this.error.value = null;
+            });
+            if (this.rootStore.featureFlags.meetingEmailValidation) {
+                const email = this.email.value.trim();
+                const isEmailValid = await this.rootStore.validateEmail(email, "Meetings");
+                if (!isEmailValid) {
+                    signals_core_module_r(()=>{
+                        this.error.value = "Invalid email address";
+                        this.loading.value = false;
+                    });
+                    return;
+                }
+            }
+            const response = await this.rootStore.sendMessage(payload, {
+                optimistic: false
+            });
+            if (response.error) {
+                throw new Error(response.error.message);
+            }
+            signals_core_module_r(()=>{
+                this.rootStore.updateMessage(offerMessage, {
+                    calendarEventBooked: true
+                });
+                this.booked.value = true;
+                this.bookedEmail.value = this.email.value;
+                this.bookedTimeSlot.value = this.selectedTimeSlot.value;
+                // Clear the loading flag so any consumer of meetingStore.loading (e.g. the
+                // Confirm button's "Confirming..." label) returns to its idle state. The
+                // error branch below does the same; both success and error paths must
+                // converge here, otherwise the button stays in a perpetual spinner in
+                // flows where activeOfferMessage does not change after booking (the
+                // element-conversation lightbox path keeps the same offer reference).
+                this.loading.value = false;
+            // Do not call close() — lightbox renders its own confirmation UI;
+            // MeetingBooker watches booked and calls close() via effect.
+            });
+        } catch (e) {
+            signals_core_module_r(()=>{
+                this.error.value = (e == null ? void 0 : e.message) || "Something went wrong. Please try again.";
+                this.loading.value = false;
+            });
+        }
+    }
+    close() {
+        this.rootStore.closeMeetingBooker();
+    }
+    reset() {
+        this.outcomeTracker.dispose();
+        signals_core_module_r(()=>{
+            this.selectedTimeSlot.value = null;
+            this.timeZone.value = getDefaultTimeZone();
+            this.step.value = "select";
+            this.email.value = "";
+            this.loading.value = false;
+            this.error.value = null;
+            this.additionalAttendees.value = [];
+            this.showAdditionalAttendeesInput.value = false;
+            this.additionalAttendeesError.value = null;
+            this.booked.value = false;
+            this.bookedEmail.value = null;
+            this.bookedTimeSlot.value = null;
+        });
+    }
+    setError(message) {
+        this.error.value = message;
+    }
+    /**
+   * Resolve the "booker showing" SLI outcome as shown — called when the booker
+   * content first renders, whether that is the slot grid or the no-availability
+   * empty state. Empty availability is a successful render (backend responded
+   * with no open times), not a booker failure.
+   */ /**
+   * @param offerMessageId The offer this render is reporting. Callers should pass
+   *   the id they rendered with rather than relying on the default: the default
+   *   reads live state, and a second offer landing between the render and this
+   *   call would report the newer id, which the intent tracker rejects as
+   *   belonging to a different intent — silently dropping the timing.
+   */ markShown(offerMessageId) {
+        if (offerMessageId === void 0) offerMessageId = (()=>{
+            var _this_activeOfferMessage_value;
+            return (_this_activeOfferMessage_value = this.activeOfferMessage.value) == null ? void 0 : _this_activeOfferMessage_value.id;
+        })();
+        this.outcomeTracker.markShown();
+        // Closes the pre-offer window's visitor-experienced total (intent -> shown).
+        // No-ops unless this offer was preceded by an intent signal on this page.
+        if (offerMessageId) this.rootStore.bookerIntentTracker.markShown(offerMessageId);
+    }
+    toggleAdditionalAttendeesInput() {
+        this.showAdditionalAttendeesInput.value = !this.showAdditionalAttendeesInput.value;
+    }
+    addAttendeeEmail(email) {
+        const trimmedEmail = email.trim();
+        if (!trimmedEmail) return false;
+        if (!this.validateEmail(trimmedEmail)) {
+            this.additionalAttendeesError.value = '"' + trimmedEmail + '" is not a valid email address';
+            return false;
+        }
+        if (this.additionalAttendees.value.includes(trimmedEmail)) {
+            this.additionalAttendeesError.value = '"' + trimmedEmail + '" is already added';
+            return false;
+        }
+        signals_core_module_r(()=>{
+            this.additionalAttendees.value = [
+                ...this.additionalAttendees.value,
+                trimmedEmail
+            ];
+            this.additionalAttendeesError.value = null;
+        });
+        return true;
+    }
+    removeAttendeeEmail(email) {
+        this.additionalAttendees.value = this.additionalAttendees.value.filter((e)=>e !== email);
+    }
+    clearAdditionalAttendeesError() {
+        this.additionalAttendeesError.value = null;
+    }
+    // Everything below is private (helpers)
+    validateEmail(email) {
+        return /.+@.+\..+/.test(email);
+    }
+    // Conversation type this surface serves. A smart-form / CTA offer arrives via
+    // the element conversation, a separate signal from the chat-only
+    // `activeConversation`; when the active offer is that element offer the
+    // conversation is `element` (-> pathway_origin `form`). Otherwise it is the
+    // chat conversation's type (AI vs human splits on offer source, not type).
+    conversationType() {
+        var _ref;
+        var _this_rootStore_activeConversation_value;
+        if (this.rootStore.elementConversationOffer.value) return "element";
+        return (_ref = (_this_rootStore_activeConversation_value = this.rootStore.activeConversation.value) == null ? void 0 : _this_rootStore_activeConversation_value.type) != null ? _ref : "chat";
+    }
+    bookerPathwayOrigin() {
+        var _this_activeOfferMessage_value;
+        // Match the server: `element` -> `form`, an `auto_respond` offer -> `ai_agent`,
+        // otherwise `chat`.
+        return bookerPathwayOrigin(this.conversationType(), (_this_activeOfferMessage_value = this.activeOfferMessage.value) == null ? void 0 : _this_activeOfferMessage_value.source);
+    }
+    initialize() {
+        const message = this.activeOfferMessage.value;
+        if (!message) return;
+        // Arm at offer-receipt (not component mount) so an offer that never renders
+        // still resolves to a terminal SLI outcome. `arm()` is internally guarded
+        // (`safely()`), so no outer try/catch is needed.
+        this.outcomeTracker.arm(message.id, this.bookerPathwayOrigin(), this.conversationType());
+        signals_core_module_r(()=>{
+            var _ref;
+            var _message_availableSlots;
+            this.selectedTimeSlot.value = (_ref = (_message_availableSlots = message.availableSlots) == null ? void 0 : _message_availableSlots[0]) != null ? _ref : null;
+            this.timeZone.value = message.timeZone || new Intl.DateTimeFormat().resolvedOptions().timeZone;
+            this.email.value = message.calendarEventInviteEmail || "";
+            this.step.value = "select";
+            this.loading.value = false;
+            this.error.value = null;
+            this.additionalAttendees.value = [];
+            this.showAdditionalAttendeesInput.value = false;
+            this.additionalAttendeesError.value = null;
+        });
+    }
+    navigateToWeek(direction) {
+        const targetSlot = direction === -1 ? this.prevSlotBeforeWeek.value : this.nextSlotAfterWeek.value;
+        if (targetSlot) {
+            this.selectTimeSlot(targetSlot);
+        }
+    }
+    navigateToPage(direction) {
+        const hasPage = direction === -1 ? this.hasPrevSlotPage.value : this.hasNextSlotPage.value;
+        if (!hasPage) return;
+        const targetIndex = (this.slotPage.value + direction) * this.slotPageSize.value;
+        const slots = this.sameDaySlots.value;
+        if (targetIndex >= 0 && targetIndex < slots.length) {
+            this.selectTimeSlot(slots[targetIndex]);
+        }
+    }
+    buildPayload() {
+        const selectedTimeSlot = this.selectedTimeSlot.value;
+        const activeOfferMessage = this.activeOfferMessage.value;
+        if (!selectedTimeSlot || !activeOfferMessage) return null;
+        const payload = {
+            type: "calendar_event_pick",
+            replyToId: activeOfferMessage.id,
+            botStep: activeOfferMessage.botStep,
+            executionStep: activeOfferMessage.executionStep,
+            calendarEventStartsAt: selectedTimeSlot.startsAt,
+            calendarEventInviteEmail: this.email.value,
+            selectedTimeZone: this.timeZone.value,
+            calendarEvent: {
+                id: esm_browser_v4(),
+                startsAt: selectedTimeSlot.startsAt,
+                endsAt: selectedTimeSlot.endsAt,
+                email: this.email.value,
+                timeZone: this.timeZone.value
+            }
+        };
+        // Include additional attendees if any
+        if (this.additionalAttendees.value.length > 0) {
+            payload.additionalAttendeesEmails = this.additionalAttendees.value;
+        }
+        return payload;
+    }
+    // eslint-disable-next-line no-useless-constructor
+    constructor(rootStore){
+        this.rootStore = rootStore;
+        // State (public)
+        this.selectedTimeSlot = signals_core_module_d(null);
+        this.timeZone = signals_core_module_d(getDefaultTimeZone());
+        this.step = signals_core_module_d("select");
+        this.email = signals_core_module_d("");
+        this.loading = signals_core_module_d(false);
+        this.error = signals_core_module_d(null);
+        this.additionalAttendees = signals_core_module_d([]);
+        this.showAdditionalAttendeesInput = signals_core_module_d(false);
+        this.additionalAttendeesError = signals_core_module_d(null);
+        // Post-booking confirmation state (set after successful booking; cleared on reset)
+        this.booked = signals_core_module_d(false);
+        this.bookedEmail = signals_core_module_d(null);
+        this.bookedTimeSlot = signals_core_module_d(null);
+        /**
+   * Which of the two slot-grid layouts is on screen. Set by whichever surface is
+   * rendering the selector, since the choice is made from context and viewport
+   * there; only one booker surface is ever mounted, so one value covers it.
+   */ this.slotLayout = signals_core_module_d("small");
+        /** How many slots a page holds, and so how many cells the grid draws. */ this.slotPageSize = signals_core_module_w(()=>PAGE_SIZE[this.slotLayout.value]);
+        // Derived state (public)
+        this.activeOfferMessage = signals_core_module_w(()=>{
+            // Fullscreen lightbox flow from smart forms/buttons takes precedence.
+            const elementOffer = this.rootStore.elementConversationOffer.value;
+            if (elementOffer) return elementOffer;
+            // Every other offer opens in the artifact overlay.
+            const artifactMessage = this.rootStore.artifact.message.value;
+            return (artifactMessage == null ? void 0 : artifactMessage.type) === "calendar_event_offer" ? artifactMessage : null;
+        });
+        // Derived state (private)
+        this.availableSlots = signals_core_module_w(()=>{
+            var _ref;
+            var _this_activeOfferMessage_value;
+            return (_ref = (_this_activeOfferMessage_value = this.activeOfferMessage.value) == null ? void 0 : _this_activeOfferMessage_value.availableSlots) != null ? _ref : [];
+        });
+        this.durationSeconds = signals_core_module_w(()=>{
+            var _ref;
+            var _this_activeOfferMessage_value;
+            return (_ref = (_this_activeOfferMessage_value = this.activeOfferMessage.value) == null ? void 0 : _this_activeOfferMessage_value.calendarEventTypeDuration) != null ? _ref : 0;
+        });
+        this.emailValid = signals_core_module_w(()=>{
+            const email = this.email.value.trim();
+            const [valid] = validateEmail(email, false);
+            return valid;
+        });
+        this.sortedSlots = signals_core_module_w(()=>[
+                ...this.availableSlots.value
+            ].sort((a, b)=>a.startsAt.localeCompare(b.startsAt)));
+        this.sameDaySlots = signals_core_module_w(()=>{
+            const slot = this.selectedTimeSlot.value;
+            if (!slot) return [];
+            const tz = this.timeZone.value;
+            return getSameDaySlots(slot, this.sortedSlots.value, tz);
+        });
+        this.sameDaySlotsEmpty = signals_core_module_w(()=>this.sameDaySlots.value.length === 0);
+        /**
+   * The page is derived from where the selected slot falls, never stored. That is
+   * what keeps a change of page size safe: resizing cannot strand the view past the
+   * last page, because there is no index to go stale — the page is recomputed from
+   * a selection that is always somewhere in the list.
+   */ this.slotPage = signals_core_module_w(()=>{
+            const slot = this.selectedTimeSlot.value;
+            if (!slot || this.sameDaySlotsEmpty.value) return 0;
+            const index = this.sameDaySlots.value.findIndex((s)=>s.startsAt === slot.startsAt);
+            return index >= 0 ? Math.floor(index / this.slotPageSize.value) : 0;
+        });
+        this.slotPageCount = signals_core_module_w(()=>Math.ceil(this.sameDaySlots.value.length / this.slotPageSize.value));
+        this.nextSlotAfterWeek = signals_core_module_w(()=>{
+            const slot = this.selectedTimeSlot.value;
+            if (!slot) return null;
+            const tz = this.timeZone.value;
+            return getNextSlotAfterWeek(slot, this.sortedSlots.value, tz);
+        });
+        this.prevSlotBeforeWeek = signals_core_module_w(()=>{
+            const slot = this.selectedTimeSlot.value;
+            if (!slot) return null;
+            const tz = this.timeZone.value;
+            return getPrevSlotBeforeWeek(slot, this.sortedSlots.value, tz);
+        });
+        this.displayedTimeSlots = signals_core_module_w(()=>this.sameDaySlots.value.slice(this.slotPage.value * this.slotPageSize.value, (this.slotPage.value + 1) * this.slotPageSize.value));
+        this.durationMinutes = signals_core_module_w(()=>Math.max(1, Math.round(this.durationSeconds.value / 60)));
+        // Public computed state
+        this.submitDisabled = $any(this.loading, $not($exists(this.selectedTimeSlot)), $not(this.emailValid), $exists(this.additionalAttendeesError));
+        this.calendarDays = signals_core_module_w(()=>{
+            const slot = this.selectedTimeSlot.value;
+            if (!slot) return [];
+            const tz = this.timeZone.value;
+            const locale = this.rootStore.translationStore.effectiveLocale.value;
+            return buildCalendarDays(slot, tz, this.sortedSlots.value, locale);
+        });
+        this.hasPrevWeek = signals_core_module_w(()=>$exists(this.prevSlotBeforeWeek).value);
+        this.hasNextWeek = signals_core_module_w(()=>$exists(this.nextSlotAfterWeek).value);
+        this.hasNextSlotPage = signals_core_module_w(()=>this.slotPage.value < this.slotPageCount.value - 1);
+        this.hasPrevSlotPage = signals_core_module_w(()=>this.slotPage.value > 0);
+        this.displayedTimeSlotItems = signals_core_module_w(()=>{
+            const slot = this.selectedTimeSlot.value;
+            const tz = this.timeZone.value;
+            const locale = this.rootStore.translationStore.effectiveLocale.value;
+            return this.displayedTimeSlots.value.map((s)=>({
+                    slot: s,
+                    label: formatTimeShort(s.startsAt, tz, locale),
+                    isSelected: s === slot
+                }));
+        });
+        this.availableDateStrings = signals_core_module_w(()=>{
+            const tz = this.timeZone.value;
+            const set = new Set();
+            const fmt = new Intl.DateTimeFormat("en-CA", {
+                timeZone: tz,
+                year: "numeric",
+                month: "2-digit",
+                day: "2-digit"
+            });
+            for (const slot of this.sortedSlots.value){
+                set.add(fmt.format(new Date(slot.startsAt)));
+            }
+            return set;
+        });
+        this.selectedDateString = signals_core_module_w(()=>{
+            const slot = this.selectedTimeSlot.value;
+            if (!slot) return null;
+            const tz = this.timeZone.value;
+            return new Intl.DateTimeFormat("en-CA", {
+                timeZone: tz,
+                year: "numeric",
+                month: "2-digit",
+                day: "2-digit"
+            }).format(new Date(slot.startsAt));
+        });
+        this.durationLabel = signals_core_module_w(()=>{
+            const minutes = this.durationMinutes.value;
+            if (!minutes) return "";
+            return this.rootStore.translationStore.t("meetings.durationMinutes", {
+                count: minutes
+            });
+        });
+        this.monthTitle = signals_core_module_w(()=>{
+            const slot = this.selectedTimeSlot.value;
+            if (!slot) return null;
+            const d = new Date(slot.startsAt);
+            const key = d.getFullYear() + "-" + ("" + (d.getMonth() + 1)).padStart(2, "0") + "-" + ("" + d.getDate()).padStart(2, "0");
+            const locale = this.rootStore.translationStore.effectiveLocale.value;
+            return formatMonthTitle(key, locale);
+        });
+        this.minDate = signals_core_module_w(()=>{
+            const slots = this.sortedSlots.value;
+            if (slots.length === 0) return null;
+            const date = new Date(slots[0].startsAt);
+            return date.getFullYear() + "-" + ("" + (date.getMonth() + 1)).padStart(2, "0") + "-" + ("" + date.getDate()).padStart(2, "0");
+        });
+        this.maxDate = signals_core_module_w(()=>{
+            const slots = this.sortedSlots.value;
+            if (slots.length === 0) return null;
+            const date = new Date(slots[slots.length - 1].startsAt);
+            return date.getFullYear() + "-" + ("" + (date.getMonth() + 1)).padStart(2, "0") + "-" + ("" + date.getDate()).padStart(2, "0");
+        });
+        // Signal subscriptions
+        this.signalSubscriptions = [
+            // Active Offer
+            ()=>this.activeOfferMessage.subscribe(this.handleActiveOfferMessageChange)
+        ];
+        this.handleActiveOfferMessageChange = (newOfferMessage)=>{
+            signals_core_module_r(()=>{
+                if (newOfferMessage) {
+                    this.initialize();
+                } else {
+                    this.reset();
+                }
+            });
+        };
+        // Emits the "booker showing" SLI outcome (shown/failed/abandoned) per offer.
+        this.outcomeTracker = new BookerOutcomeTracker({
+            surface: BOOKER_SURFACE.MULTIMODAL,
+            log: (params)=>{
+                // Mirrors what `widget.serverLog` does for the legacy booker. This store
+                // logs through the module singleton rather than the widget wrapper, so
+                // without this the host-side form/CTA tracker never observes a multimodal
+                // booker being shown — and the element lightbox, which is the multimodal
+                // form pathway, would silently lose its intent -> shown timing.
+                observeBookerOutcome(params);
+                serverLogger.serverLog(params);
+            }
+        });
+        this.signalSubscriptions.forEach((subscription)=>subscription());
+    }
+}
+/* export default */ const meeting_store = (MeetingStore);
+
+export { MeetingStore, meeting_store_Step as Step };
+export default meeting_store;

package/widget/multimodal_v2/stores/participant_store.js

@@ -0,0 +1,73 @@
+import { signals_core_module_d, signals_core_module_w } from "../../../js/multimodal_v2.js";
+import { AvatarProvider as types_AvatarProvider } from "../types.js";
+
+function _extends() {
+    _extends = Object.assign || function(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = arguments[i];
+            for(var key in source){
+                if (Object.prototype.hasOwnProperty.call(source, key)) {
+                    target[key] = source[key];
+                }
+            }
+        }
+        return target;
+    };
+    return _extends.apply(this, arguments);
+}
+
+
+class ParticipantStore {
+    dispose() {
+        this.participants.value = {};
+    }
+    // eslint-disable-next-line no-useless-constructor
+    constructor(callStore){
+        this.callStore = callStore;
+        // participants
+        this.participants = signals_core_module_d({});
+        // Computed
+        this.avatarParticipant = signals_core_module_w(()=>{
+            const participants = this.participants.value;
+            const avatarParticipant = Object.values(participants).find((p)=>p.user_name === "Tavus Echo Audio Stream");
+            return avatarParticipant || null;
+        });
+        this.coffeeAgentParticipant = signals_core_module_w(()=>{
+            const participants = this.participants.value;
+            const coffeeAgentParticipant = Object.values(participants).find((p)=>p.user_name === "Agent");
+            return coffeeAgentParticipant || null;
+        });
+        /**
+   * The participant whose video track is the avatar.
+   *
+   * With failovers enabled this follows the provider Coffee reports rather than which tracks
+   * exist: the bot publishes a video track from the moment it joins and leaves it empty unless an
+   * Anam cutover commits, so track presence says nothing about which one to render.
+   *
+   * With failovers off there is only ever one candidate, so this stays on the original per-team
+   * flag and ignores the reported provider entirely.
+   */ this.videoParticipant = signals_core_module_w(()=>{
+            const { rootStore } = this.callStore;
+            if (rootStore.featureFlags.piperXEnableVideoFailovers) {
+                switch(rootStore.activeAvatarProvider.value){
+                    case types_AvatarProvider.ANAM:
+                        return this.coffeeAgentParticipant.value;
+                    case types_AvatarProvider.TAVUS:
+                        return this.avatarParticipant.value;
+                    default:
+                        break;
+                }
+            }
+            const isAnam = rootStore.featureFlags.piperXAnam;
+            return isAnam ? this.coffeeAgentParticipant.value : this.avatarParticipant.value;
+        });
+        this.updateParticipants = ()=>{
+            const call = this.callStore.dailyCall.value;
+            if (!call) return;
+            this.participants.value = _extends({}, call.participants());
+        };
+    }
+}
+
+
+export default ParticipantStore;