@dcl/asset-packs 2.14.2 → 2.15.0

package/dist/admin-toolkit-ui/VideoControl/DclCast/SpeakerShowcase.js

@@ -0,0 +1,110 @@
+import ReactEcs, { Dropdown, UiEntity, Label } from '@dcl/react-ecs';
+import { getContentUrl } from '../../constants';
+import { Button } from '../../Button';
+import { Modal } from '../../Modal';
+import { getSourceLabel, isPresentationBot } from '../api';
+import { getSpeakerShowcaseStyles, getShowcaseColors, getShowcaseBackgrounds, getShowcaseIconBackgrounds, getPaginationColor, SHOWCASE_DROPDOWN_COLORS, SHOWCASE_PAGE_INDICATOR_COLOR, } from './styles';
+const SPEAKERS_PER_PAGE = 10;
+const ICONS = {
+    get BACK() {
+        return `${getContentUrl()}/admin_toolkit/assets/icons/chevron-back.png`;
+    },
+    get NEXT() {
+        return `${getContentUrl()}/admin_toolkit/assets/icons/chevron-forward.png`;
+    },
+    get STAR() {
+        return `${getContentUrl()}/admin_toolkit/assets/icons/star.png`;
+    },
+};
+function getDropdownOptions(participant) {
+    return participant.tracks.map(track => `${getSourceLabel(track.sourceType)}`);
+}
+function getActiveIndex(participant, activeTrackSid) {
+    if (!activeTrackSid)
+        return -1;
+    return participant.tracks.findIndex(t => t.sid === activeTrackSid);
+}
+function ParticipantRow({ participant, activeTrackSid, isHovered, onSelectTrack, onHoverEnter, onHoverLeave, }) {
+    const styles = getSpeakerShowcaseStyles();
+    const backgrounds = getShowcaseBackgrounds();
+    const colors = getShowcaseColors();
+    const iconBgs = getShowcaseIconBackgrounds();
+    const isBot = isPresentationBot(participant.name);
+    const displayName = isBot ? 'Presentation' : participant.name;
+    const activeIndex = getActiveIndex(participant, activeTrackSid);
+    const isActive = activeIndex !== -1;
+    const options = getDropdownOptions(participant);
+    const displayLabel = isActive
+        ? getSourceLabel(participant.tracks[activeIndex].sourceType)
+        : 'Showcase';
+    const dropdownTextColor = isHovered
+        ? SHOWCASE_DROPDOWN_COLORS.hover
+        : isActive
+            ? SHOWCASE_DROPDOWN_COLORS.active
+            : SHOWCASE_DROPDOWN_COLORS.idle;
+    const dropdownBgColor = isHovered
+        ? SHOWCASE_DROPDOWN_COLORS.hoverBg
+        : SHOWCASE_DROPDOWN_COLORS.transparentBg;
+    return (ReactEcs.createElement(UiEntity, { uiTransform: styles.userItem },
+        ReactEcs.createElement(UiEntity, { uiTransform: styles.userRow },
+            ReactEcs.createElement(UiEntity, { uiTransform: styles.userInfo },
+                ReactEcs.createElement(UiEntity, { uiTransform: styles.personIconContainer },
+                    ReactEcs.createElement(UiEntity, { uiTransform: styles.personIcon, uiBackground: backgrounds.personIcon })),
+                ReactEcs.createElement(UiEntity, { uiTransform: styles.userDetails },
+                    ReactEcs.createElement(Label, { value: `<b>${displayName}</b>`, fontSize: 14, color: colors.white }))),
+            ReactEcs.createElement(UiEntity, { uiTransform: styles.rowCenter }, isBot ? (ReactEcs.createElement(Button, { id: `showcase-activate-${participant.identity}`, value: isActive ? '<b>Active</b>' : '<b>Activate</b>', variant: isActive ? 'primary' : 'secondary', disabled: isActive, fontSize: 14, color: colors.white, uiTransform: styles.dropdownTransform, onMouseDown: () => {
+                    const track = participant.tracks[0];
+                    if (track) {
+                        onSelectTrack(track);
+                    }
+                } })) : (ReactEcs.createElement(UiEntity, { uiTransform: styles.rowCenter },
+                ReactEcs.createElement(UiEntity, { uiTransform: { ...styles.starIcon, display: isActive ? 'flex' : 'none' }, uiBackground: iconBgs.star }),
+                ReactEcs.createElement(UiEntity, { uiTransform: styles.dropdownWrapper, onMouseEnter: onHoverEnter, onMouseLeave: onHoverLeave },
+                    ReactEcs.createElement(Dropdown, { key: `showcase-dropdown-${participant.identity}-${activeTrackSid ?? 'none'}`, acceptEmpty: true, emptyLabel: displayLabel, options: options, selectedIndex: -1, onChange: (optionIndex) => {
+                            const track = participant.tracks[optionIndex];
+                            if (track) {
+                                onSelectTrack(track);
+                            }
+                        }, textAlign: "middle-left", fontSize: 14, uiTransform: styles.dropdownTransform, uiBackground: { color: dropdownBgColor }, color: dropdownTextColor })))))),
+        ReactEcs.createElement(UiEntity, { uiTransform: styles.divider, uiBackground: backgrounds.divider })));
+}
+export function SpeakerShowcase({ participants, activeTrackSid, onSelectTrack, onSetDefault, onClose, }) {
+    const [page, setPage] = ReactEcs.useState(1);
+    const [hoveredDropdown, setHoveredDropdown] = ReactEcs.useState(undefined);
+    const isDefaultActive = !activeTrackSid;
+    const styles = getSpeakerShowcaseStyles();
+    const colors = getShowcaseColors();
+    const iconBgs = getShowcaseIconBackgrounds();
+    const totalPages = Math.ceil(participants.length / SPEAKERS_PER_PAGE);
+    const startIndex = (page - 1) * SPEAKERS_PER_PAGE;
+    const endIndex = Math.min(startIndex + SPEAKERS_PER_PAGE, participants.length);
+    const currentPageParticipants = participants.slice(startIndex, endIndex);
+    const paginationFooter = participants.length > SPEAKERS_PER_PAGE && (ReactEcs.createElement(UiEntity, { uiTransform: styles.pagination },
+        ReactEcs.createElement(Button, { id: "showcase-prev", value: "Prev", variant: "secondary", disabled: page <= 1, fontSize: 18, icon: ICONS.BACK, iconTransform: styles.prevIcon, iconBackground: { color: getPaginationColor(page <= 1) }, color: getPaginationColor(page <= 1), labelTransform: styles.prevLabel, uiTransform: styles.paginationButton, onMouseDown: () => setPage(page - 1) }),
+        ReactEcs.createElement(Label, { value: `Page ${page}/${totalPages}`, fontSize: 14, color: SHOWCASE_PAGE_INDICATOR_COLOR }),
+        ReactEcs.createElement(Button, { id: "showcase-next", value: "<b>Next</b>", variant: "secondary", fontSize: 18, iconRight: ICONS.NEXT, iconRightTransform: styles.nextIcon, labelTransform: styles.nextLabel, iconRightBackground: {
+                color: getPaginationColor(page >= totalPages),
+            }, color: getPaginationColor(page >= totalPages), disabled: page >= totalPages, uiTransform: styles.paginationButton, onMouseDown: () => setPage(page + 1) })));
+    return (ReactEcs.createElement(Modal, { id: "showcase", title: "SPEAKER SHOWCASE", titleFontSize: 20, headerIcon: iconBgs.showcase, headerIconSize: 24, headerMarginBottom: 16, counterText: `(${participants.length} Speakers)`, counterFontSize: 14, width: 650, height: 650, padding: 16, onClose: onClose, footer: paginationFooter || undefined },
+        ReactEcs.createElement(UiEntity, { uiTransform: { flexDirection: 'column', width: '100%' } },
+            ReactEcs.createElement(UiEntity, { uiTransform: styles.toggleRow, uiBackground: { color: colors.softBlack } },
+                ReactEcs.createElement(UiEntity, { uiTransform: { flexDirection: 'column' } },
+                    ReactEcs.createElement(Label, { value: "Automatic Showcase", fontSize: 14, color: colors.white }),
+                    ReactEcs.createElement(Label, { value: "Speakers will be automatically featured when they speak", fontSize: 10, color: colors.gray })),
+                ReactEcs.createElement(Button, { id: "showcase-default-speaker", value: isDefaultActive ? 'Active' : 'Turn On', variant: "secondary", disabled: isDefaultActive, fontSize: 14, color: colors.white, icon: ICONS.STAR, iconTransform: {
+                        ...styles.starIcon,
+                        display: isDefaultActive ? 'flex' : 'none',
+                    }, iconBackground: { color: colors.white }, uiTransform: {
+                        ...styles.toggleButton,
+                        ...(isDefaultActive ? { borderColor: colors.transparent } : {}),
+                    }, onMouseDown: () => {
+                        if (!isDefaultActive) {
+                            onSetDefault();
+                        }
+                    } })),
+            ReactEcs.createElement(UiEntity, { uiTransform: styles.listContainer },
+                participants.length === 0 && (ReactEcs.createElement(UiEntity, { uiTransform: styles.messageContainer },
+                    ReactEcs.createElement(Label, { value: "No current active participants in the Cast", fontSize: 16, color: colors.gray }))),
+                currentPageParticipants.map(participant => (ReactEcs.createElement(ParticipantRow, { key: participant.identity, participant: participant, activeTrackSid: activeTrackSid, isHovered: hoveredDropdown === participant.identity, onSelectTrack: onSelectTrack, onHoverEnter: () => setHoveredDropdown(participant.identity), onHoverLeave: () => setHoveredDropdown(undefined) })))))));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SpeakerShowcase.js","sourceRoot":"","sources":["../../../../src/admin-toolkit-ui/VideoControl/DclCast/SpeakerShowcase.tsx"],"names":[],"mappings":"AAAA,OAAO,QAAQ,EAAE,EAAE,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AACrE,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AACtC,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAyC,MAAM,QAAQ,CAAC;AAClG,OAAO,EACL,wBAAwB,EACxB,iBAAiB,EACjB,sBAAsB,EACtB,0BAA0B,EAC1B,kBAAkB,EAClB,wBAAwB,EACxB,6BAA6B,GAC9B,MAAM,UAAU,CAAC;AAElB,MAAM,iBAAiB,GAAG,EAAE,CAAC;AAE7B,MAAM,KAAK,GAAG;IACZ,IAAI,IAAI;QACN,OAAO,GAAG,aAAa,EAAE,8CAA8C,CAAC;IAC1E,CAAC;IACD,IAAI,IAAI;QACN,OAAO,GAAG,aAAa,EAAE,iDAAiD,CAAC;IAC7E,CAAC;IACD,IAAI,IAAI;QACN,OAAO,GAAG,aAAa,EAAE,sCAAsC,CAAC;IAClE,CAAC;CACF,CAAC;AAUF,SAAS,kBAAkB,CAAC,WAAwB;IAClD,OAAO,WAAW,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,GAAG,cAAc,CAAC,KAAK,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC;AAChF,CAAC;AAED,SAAS,cAAc,CAAC,WAAwB,EAAE,cAAkC;IAClF,IAAI,CAAC,cAAc;QAAE,OAAO,CAAC,CAAC,CAAC;IAC/B,OAAO,WAAW,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,KAAK,cAAc,CAAC,CAAC;AACrE,CAAC;AAED,SAAS,cAAc,CAAC,EACtB,WAAW,EACX,cAAc,EACd,SAAS,EACT,aAAa,EACb,YAAY,EACZ,YAAY,GASb;IACC,MAAM,MAAM,GAAG,wBAAwB,EAAE,CAAC;IAC1C,MAAM,WAAW,GAAG,sBAAsB,EAAE,CAAC;IAC7C,MAAM,MAAM,GAAG,iBAAiB,EAAE,CAAC;IACnC,MAAM,OAAO,GAAG,0BAA0B,EAAE,CAAC;IAE7C,MAAM,KAAK,GAAG,iBAAiB,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;IAClD,MAAM,WAAW,GAAG,KAAK,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,WAAW,CAAC,IAAI,CAAC;IAC9D,MAAM,WAAW,GAAG,cAAc,CAAC,WAAW,EAAE,cAAc,CAAC,CAAC;IAChE,MAAM,QAAQ,GAAG,WAAW,KAAK,CAAC,CAAC,CAAC;IACpC,MAAM,OAAO,GAAG,kBAAkB,CAAC,WAAW,CAAC,CAAC;IAChD,MAAM,YAAY,GAAG,QAAQ;QAC3B,CAAC,CAAC,cAAc,CAAC,WAAW,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,UAAU,CAAC;QAC5D,CAAC,CAAC,UAAU,CAAC;IAEf,MAAM,iBAAiB,GAAG,SAAS;QACjC,CAAC,CAAC,wBAAwB,CAAC,KAAK;QAChC,CAAC,CAAC,QAAQ;YACR,CAAC,CAAC,wBAAwB,CAAC,MAAM;YACjC,CAAC,CAAC,wBAAwB,CAAC,IAAI,CAAC;IAEpC,MAAM,eAAe,GAAG,SAAS;QAC/B,CAAC,CAAC,wBAAwB,CAAC,OAAO;QAClC,CAAC,CAAC,wBAAwB,CAAC,aAAa,CAAC;IAE3C,OAAO,CACL,uBAAC,QAAQ,IAAC,WAAW,EAAE,MAAM,CAAC,QAAQ;QACpC,uBAAC,QAAQ,IAAC,WAAW,EAAE,MAAM,CAAC,OAAO;YACnC,uBAAC,QAAQ,IAAC,WAAW,EAAE,MAAM,CAAC,QAAQ;gBACpC,uBAAC,QAAQ,IAAC,WAAW,EAAE,MAAM,CAAC,mBAAmB;oBAC/C,uBAAC,QAAQ,IACP,WAAW,EAAE,MAAM,CAAC,UAAU,EAC9B,YAAY,EAAE,WAAW,CAAC,UAAU,GACpC,CACO;gBACX,uBAAC,QAAQ,IAAC,WAAW,EAAE,MAAM,CAAC,WAAW;oBACvC,uBAAC,KAAK,IACJ,KAAK,EAAE,MAAM,WAAW,MAAM,EAC9B,QAAQ,EAAE,EAAE,EACZ,KAAK,EAAE,MAAM,CAAC,KAAK,GACnB,CACO,CACF;YACX,uBAAC,QAAQ,IAAC,WAAW,EAAE,MAAM,CAAC,SAAS,IACpC,KAAK,CAAC,CAAC,CAAC,CACP,uBAAC,MAAM,IACL,EAAE,EAAE,qBAAqB,WAAW,CAAC,QAAQ,EAAE,EAC/C,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,iBAAiB,EACrD,OAAO,EAAE,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,WAAW,EAC3C,QAAQ,EAAE,QAAQ,EAClB,QAAQ,EAAE,EAAE,EACZ,KAAK,EAAE,MAAM,CAAC,KAAK,EACnB,WAAW,EAAE,MAAM,CAAC,iBAAiB,EACrC,WAAW,EAAE,GAAG,EAAE;oBAChB,MAAM,KAAK,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;oBACpC,IAAI,KAAK,EAAE,CAAC;wBACV,aAAa,CAAC,KAAK,CAAC,CAAC;oBACvB,CAAC;gBACH,CAAC,GACD,CACH,CAAC,CAAC,CAAC,CACF,uBAAC,QAAQ,IAAC,WAAW,EAAE,MAAM,CAAC,SAAS;gBACrC,uBAAC,QAAQ,IACP,WAAW,EAAE,EAAE,GAAG,MAAM,CAAC,QAAQ,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EACxE,YAAY,EAAE,OAAO,CAAC,IAAI,GAC1B;gBACF,uBAAC,QAAQ,IACP,WAAW,EAAE,MAAM,CAAC,eAAe,EACnC,YAAY,EAAE,YAAY,EAC1B,YAAY,EAAE,YAAY;oBAE1B,uBAAC,QAAQ,IACP,GAAG,EAAE,qBAAqB,WAAW,CAAC,QAAQ,IAAI,cAAc,IAAI,MAAM,EAAE,EAC5E,WAAW,QACX,UAAU,EAAE,YAAY,EACxB,OAAO,EAAE,OAAO,EAChB,aAAa,EAAE,CAAC,CAAC,EACjB,QAAQ,EAAE,CAAC,WAAmB,EAAE,EAAE;4BAChC,MAAM,KAAK,GAAG,WAAW,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;4BAC9C,IAAI,KAAK,EAAE,CAAC;gCACV,aAAa,CAAC,KAAK,CAAC,CAAC;4BACvB,CAAC;wBACH,CAAC,EACD,SAAS,EAAC,aAAa,EACvB,QAAQ,EAAE,EAAE,EACZ,WAAW,EAAE,MAAM,CAAC,iBAAiB,EACrC,YAAY,EAAE,EAAE,KAAK,EAAE,eAAe,EAAE,EACxC,KAAK,EAAE,iBAAiB,GACxB,CACO,CACF,CACZ,CACQ,CACF;QACX,uBAAC,QAAQ,IACP,WAAW,EAAE,MAAM,CAAC,OAAO,EAC3B,YAAY,EAAE,WAAW,CAAC,OAAO,GACjC,CACO,CACZ,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,eAAe,CAAC,EAC9B,YAAY,EACZ,cAAc,EACd,aAAa,EACb,YAAY,EACZ,OAAO,GACc;IACrB,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,GAAG,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;IAC7C,MAAM,CAAC,eAAe,EAAE,kBAAkB,CAAC,GAAG,QAAQ,CAAC,QAAQ,CAAqB,SAAS,CAAC,CAAC;IAC/F,MAAM,eAAe,GAAG,CAAC,cAAc,CAAC;IAExC,MAAM,MAAM,GAAG,wBAAwB,EAAE,CAAC;IAC1C,MAAM,MAAM,GAAG,iBAAiB,EAAE,CAAC;IACnC,MAAM,OAAO,GAAG,0BAA0B,EAAE,CAAC;IAE7C,MAAM,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,MAAM,GAAG,iBAAiB,CAAC,CAAC;IACtE,MAAM,UAAU,GAAG,CAAC,IAAI,GAAG,CAAC,CAAC,GAAG,iBAAiB,CAAC;IAClD,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,UAAU,GAAG,iBAAiB,EAAE,YAAY,CAAC,MAAM,CAAC,CAAC;IAC/E,MAAM,uBAAuB,GAAG,YAAY,CAAC,KAAK,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;IAEzE,MAAM,gBAAgB,GAAG,YAAY,CAAC,MAAM,GAAG,iBAAiB,IAAI,CAClE,uBAAC,QAAQ,IAAC,WAAW,EAAE,MAAM,CAAC,UAAU;QACtC,uBAAC,MAAM,IACL,EAAE,EAAC,eAAe,EAClB,KAAK,EAAC,MAAM,EACZ,OAAO,EAAC,WAAW,EACnB,QAAQ,EAAE,IAAI,IAAI,CAAC,EACnB,QAAQ,EAAE,EAAE,EACZ,IAAI,EAAE,KAAK,CAAC,IAAI,EAChB,aAAa,EAAE,MAAM,CAAC,QAAQ,EAC9B,cAAc,EAAE,EAAE,KAAK,EAAE,kBAAkB,CAAC,IAAI,IAAI,CAAC,CAAC,EAAE,EACxD,KAAK,EAAE,kBAAkB,CAAC,IAAI,IAAI,CAAC,CAAC,EACpC,cAAc,EAAE,MAAM,CAAC,SAAS,EAChC,WAAW,EAAE,MAAM,CAAC,gBAAgB,EACpC,WAAW,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,IAAI,GAAG,CAAC,CAAC,GACpC;QACF,uBAAC,KAAK,IACJ,KAAK,EAAE,QAAQ,IAAI,IAAI,UAAU,EAAE,EACnC,QAAQ,EAAE,EAAE,EACZ,KAAK,EAAE,6BAA6B,GACpC;QACF,uBAAC,MAAM,IACL,EAAE,EAAC,eAAe,EAClB,KAAK,EAAC,aAAa,EACnB,OAAO,EAAC,WAAW,EACnB,QAAQ,EAAE,EAAE,EACZ,SAAS,EAAE,KAAK,CAAC,IAAI,EACrB,kBAAkB,EAAE,MAAM,CAAC,QAAQ,EACnC,cAAc,EAAE,MAAM,CAAC,SAAS,EAChC,mBAAmB,EAAE;gBACnB,KAAK,EAAE,kBAAkB,CAAC,IAAI,IAAI,UAAU,CAAC;aAC9C,EACD,KAAK,EAAE,kBAAkB,CAAC,IAAI,IAAI,UAAU,CAAC,EAC7C,QAAQ,EAAE,IAAI,IAAI,UAAU,EAC5B,WAAW,EAAE,MAAM,CAAC,gBAAgB,EACpC,WAAW,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,IAAI,GAAG,CAAC,CAAC,GACpC,CACO,CACZ,CAAC;IAEF,OAAO,CACL,uBAAC,KAAK,IACJ,EAAE,EAAC,UAAU,EACb,KAAK,EAAC,kBAAkB,EACxB,aAAa,EAAE,EAAE,EACjB,UAAU,EAAE,OAAO,CAAC,QAAQ,EAC5B,cAAc,EAAE,EAAE,EAClB,kBAAkB,EAAE,EAAE,EACtB,WAAW,EAAE,IAAI,YAAY,CAAC,MAAM,YAAY,EAChD,eAAe,EAAE,EAAE,EACnB,KAAK,EAAE,GAAG,EACV,MAAM,EAAE,GAAG,EACX,OAAO,EAAE,EAAE,EACX,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,gBAAgB,IAAI,SAAS;QAErC,uBAAC,QAAQ,IAAC,WAAW,EAAE,EAAE,aAAa,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE;YAC/D,uBAAC,QAAQ,IACP,WAAW,EAAE,MAAM,CAAC,SAAS,EAC7B,YAAY,EAAE,EAAE,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE;gBAEzC,uBAAC,QAAQ,IAAC,WAAW,EAAE,EAAE,aAAa,EAAE,QAAQ,EAAE;oBAChD,uBAAC,KAAK,IACJ,KAAK,EAAC,oBAAoB,EAC1B,QAAQ,EAAE,EAAE,EACZ,KAAK,EAAE,MAAM,CAAC,KAAK,GACnB;oBACF,uBAAC,KAAK,IACJ,KAAK,EAAC,yDAAyD,EAC/D,QAAQ,EAAE,EAAE,EACZ,KAAK,EAAE,MAAM,CAAC,IAAI,GAClB,CACO;gBACX,uBAAC,MAAM,IACL,EAAE,EAAC,0BAA0B,EAC7B,KAAK,EAAE,eAAe,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,EAC7C,OAAO,EAAC,WAAW,EACnB,QAAQ,EAAE,eAAe,EACzB,QAAQ,EAAE,EAAE,EACZ,KAAK,EAAE,MAAM,CAAC,KAAK,EACnB,IAAI,EAAE,KAAK,CAAC,IAAI,EAChB,aAAa,EAAE;wBACb,GAAG,MAAM,CAAC,QAAQ;wBAClB,OAAO,EAAE,eAAe,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM;qBAC3C,EACD,cAAc,EAAE,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,EAAE,EACvC,WAAW,EAAE;wBACX,GAAG,MAAM,CAAC,YAAY;wBACtB,GAAG,CAAC,eAAe,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,MAAM,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;qBAChE,EACD,WAAW,EAAE,GAAG,EAAE;wBAChB,IAAI,CAAC,eAAe,EAAE,CAAC;4BACrB,YAAY,EAAE,CAAC;wBACjB,CAAC;oBACH,CAAC,GACD,CACO;YAEX,uBAAC,QAAQ,IAAC,WAAW,EAAE,MAAM,CAAC,aAAa;gBACxC,YAAY,CAAC,MAAM,KAAK,CAAC,IAAI,CAC5B,uBAAC,QAAQ,IAAC,WAAW,EAAE,MAAM,CAAC,gBAAgB;oBAC5C,uBAAC,KAAK,IACJ,KAAK,EAAC,4CAA4C,EAClD,QAAQ,EAAE,EAAE,EACZ,KAAK,EAAE,MAAM,CAAC,IAAI,GAClB,CACO,CACZ;gBACA,uBAAuB,CAAC,GAAG,CAAC,WAAW,CAAC,EAAE,CAAC,CAC1C,uBAAC,cAAc,IACb,GAAG,EAAE,WAAW,CAAC,QAAQ,EACzB,WAAW,EAAE,WAAW,EACxB,cAAc,EAAE,cAAc,EAC9B,SAAS,EAAE,eAAe,KAAK,WAAW,CAAC,QAAQ,EACnD,aAAa,EAAE,aAAa,EAC5B,YAAY,EAAE,GAAG,EAAE,CAAC,kBAAkB,CAAC,WAAW,CAAC,QAAQ,CAAC,EAC5D,YAAY,EAAE,GAAG,EAAE,CAAC,kBAAkB,CAAC,SAAS,CAAC,GACjD,CACH,CAAC,CACO,CACF,CACL,CACT,CAAC;AACJ,CAAC","sourcesContent":["import ReactEcs, { Dropdown, UiEntity, Label } from '@dcl/react-ecs';\nimport { getContentUrl } from '../../constants';\nimport { Button } from '../../Button';\nimport { Modal } from '../../Modal';\nimport { getSourceLabel, isPresentationBot, type FlattenedTrack, type Participant } from '../api';\nimport {\n  getSpeakerShowcaseStyles,\n  getShowcaseColors,\n  getShowcaseBackgrounds,\n  getShowcaseIconBackgrounds,\n  getPaginationColor,\n  SHOWCASE_DROPDOWN_COLORS,\n  SHOWCASE_PAGE_INDICATOR_COLOR,\n} from './styles';\n\nconst SPEAKERS_PER_PAGE = 10;\n\nconst ICONS = {\n  get BACK() {\n    return `${getContentUrl()}/admin_toolkit/assets/icons/chevron-back.png`;\n  },\n  get NEXT() {\n    return `${getContentUrl()}/admin_toolkit/assets/icons/chevron-forward.png`;\n  },\n  get STAR() {\n    return `${getContentUrl()}/admin_toolkit/assets/icons/star.png`;\n  },\n};\n\ntype SpeakerShowcaseProps = {\n  participants: Participant[];\n  activeTrackSid: string | undefined;\n  onSelectTrack: (track: FlattenedTrack) => void;\n  onSetDefault: () => void;\n  onClose: () => void;\n};\n\nfunction getDropdownOptions(participant: Participant): string[] {\n  return participant.tracks.map(track => `${getSourceLabel(track.sourceType)}`);\n}\n\nfunction getActiveIndex(participant: Participant, activeTrackSid: string | undefined): number {\n  if (!activeTrackSid) return -1;\n  return participant.tracks.findIndex(t => t.sid === activeTrackSid);\n}\n\nfunction ParticipantRow({\n  participant,\n  activeTrackSid,\n  isHovered,\n  onSelectTrack,\n  onHoverEnter,\n  onHoverLeave,\n}: {\n  key?: string;\n  participant: Participant;\n  activeTrackSid: string | undefined;\n  isHovered: boolean;\n  onSelectTrack: (track: FlattenedTrack) => void;\n  onHoverEnter: () => void;\n  onHoverLeave: () => void;\n}) {\n  const styles = getSpeakerShowcaseStyles();\n  const backgrounds = getShowcaseBackgrounds();\n  const colors = getShowcaseColors();\n  const iconBgs = getShowcaseIconBackgrounds();\n\n  const isBot = isPresentationBot(participant.name);\n  const displayName = isBot ? 'Presentation' : participant.name;\n  const activeIndex = getActiveIndex(participant, activeTrackSid);\n  const isActive = activeIndex !== -1;\n  const options = getDropdownOptions(participant);\n  const displayLabel = isActive\n    ? getSourceLabel(participant.tracks[activeIndex].sourceType)\n    : 'Showcase';\n\n  const dropdownTextColor = isHovered\n    ? SHOWCASE_DROPDOWN_COLORS.hover\n    : isActive\n      ? SHOWCASE_DROPDOWN_COLORS.active\n      : SHOWCASE_DROPDOWN_COLORS.idle;\n\n  const dropdownBgColor = isHovered\n    ? SHOWCASE_DROPDOWN_COLORS.hoverBg\n    : SHOWCASE_DROPDOWN_COLORS.transparentBg;\n\n  return (\n    <UiEntity uiTransform={styles.userItem}>\n      <UiEntity uiTransform={styles.userRow}>\n        <UiEntity uiTransform={styles.userInfo}>\n          <UiEntity uiTransform={styles.personIconContainer}>\n            <UiEntity\n              uiTransform={styles.personIcon}\n              uiBackground={backgrounds.personIcon}\n            />\n          </UiEntity>\n          <UiEntity uiTransform={styles.userDetails}>\n            <Label\n              value={`<b>${displayName}</b>`}\n              fontSize={14}\n              color={colors.white}\n            />\n          </UiEntity>\n        </UiEntity>\n        <UiEntity uiTransform={styles.rowCenter}>\n          {isBot ? (\n            <Button\n              id={`showcase-activate-${participant.identity}`}\n              value={isActive ? '<b>Active</b>' : '<b>Activate</b>'}\n              variant={isActive ? 'primary' : 'secondary'}\n              disabled={isActive}\n              fontSize={14}\n              color={colors.white}\n              uiTransform={styles.dropdownTransform}\n              onMouseDown={() => {\n                const track = participant.tracks[0];\n                if (track) {\n                  onSelectTrack(track);\n                }\n              }}\n            />\n          ) : (\n            <UiEntity uiTransform={styles.rowCenter}>\n              <UiEntity\n                uiTransform={{ ...styles.starIcon, display: isActive ? 'flex' : 'none' }}\n                uiBackground={iconBgs.star}\n              />\n              <UiEntity\n                uiTransform={styles.dropdownWrapper}\n                onMouseEnter={onHoverEnter}\n                onMouseLeave={onHoverLeave}\n              >\n                <Dropdown\n                  key={`showcase-dropdown-${participant.identity}-${activeTrackSid ?? 'none'}`}\n                  acceptEmpty\n                  emptyLabel={displayLabel}\n                  options={options}\n                  selectedIndex={-1}\n                  onChange={(optionIndex: number) => {\n                    const track = participant.tracks[optionIndex];\n                    if (track) {\n                      onSelectTrack(track);\n                    }\n                  }}\n                  textAlign=\"middle-left\"\n                  fontSize={14}\n                  uiTransform={styles.dropdownTransform}\n                  uiBackground={{ color: dropdownBgColor }}\n                  color={dropdownTextColor}\n                />\n              </UiEntity>\n            </UiEntity>\n          )}\n        </UiEntity>\n      </UiEntity>\n      <UiEntity\n        uiTransform={styles.divider}\n        uiBackground={backgrounds.divider}\n      />\n    </UiEntity>\n  );\n}\n\nexport function SpeakerShowcase({\n  participants,\n  activeTrackSid,\n  onSelectTrack,\n  onSetDefault,\n  onClose,\n}: SpeakerShowcaseProps) {\n  const [page, setPage] = ReactEcs.useState(1);\n  const [hoveredDropdown, setHoveredDropdown] = ReactEcs.useState<string | undefined>(undefined);\n  const isDefaultActive = !activeTrackSid;\n\n  const styles = getSpeakerShowcaseStyles();\n  const colors = getShowcaseColors();\n  const iconBgs = getShowcaseIconBackgrounds();\n\n  const totalPages = Math.ceil(participants.length / SPEAKERS_PER_PAGE);\n  const startIndex = (page - 1) * SPEAKERS_PER_PAGE;\n  const endIndex = Math.min(startIndex + SPEAKERS_PER_PAGE, participants.length);\n  const currentPageParticipants = participants.slice(startIndex, endIndex);\n\n  const paginationFooter = participants.length > SPEAKERS_PER_PAGE && (\n    <UiEntity uiTransform={styles.pagination}>\n      <Button\n        id=\"showcase-prev\"\n        value=\"Prev\"\n        variant=\"secondary\"\n        disabled={page <= 1}\n        fontSize={18}\n        icon={ICONS.BACK}\n        iconTransform={styles.prevIcon}\n        iconBackground={{ color: getPaginationColor(page <= 1) }}\n        color={getPaginationColor(page <= 1)}\n        labelTransform={styles.prevLabel}\n        uiTransform={styles.paginationButton}\n        onMouseDown={() => setPage(page - 1)}\n      />\n      <Label\n        value={`Page ${page}/${totalPages}`}\n        fontSize={14}\n        color={SHOWCASE_PAGE_INDICATOR_COLOR}\n      />\n      <Button\n        id=\"showcase-next\"\n        value=\"<b>Next</b>\"\n        variant=\"secondary\"\n        fontSize={18}\n        iconRight={ICONS.NEXT}\n        iconRightTransform={styles.nextIcon}\n        labelTransform={styles.nextLabel}\n        iconRightBackground={{\n          color: getPaginationColor(page >= totalPages),\n        }}\n        color={getPaginationColor(page >= totalPages)}\n        disabled={page >= totalPages}\n        uiTransform={styles.paginationButton}\n        onMouseDown={() => setPage(page + 1)}\n      />\n    </UiEntity>\n  );\n\n  return (\n    <Modal\n      id=\"showcase\"\n      title=\"SPEAKER SHOWCASE\"\n      titleFontSize={20}\n      headerIcon={iconBgs.showcase}\n      headerIconSize={24}\n      headerMarginBottom={16}\n      counterText={`(${participants.length} Speakers)`}\n      counterFontSize={14}\n      width={650}\n      height={650}\n      padding={16}\n      onClose={onClose}\n      footer={paginationFooter || undefined}\n    >\n      <UiEntity uiTransform={{ flexDirection: 'column', width: '100%' }}>\n        <UiEntity\n          uiTransform={styles.toggleRow}\n          uiBackground={{ color: colors.softBlack }}\n        >\n          <UiEntity uiTransform={{ flexDirection: 'column' }}>\n            <Label\n              value=\"Automatic Showcase\"\n              fontSize={14}\n              color={colors.white}\n            />\n            <Label\n              value=\"Speakers will be automatically featured when they speak\"\n              fontSize={10}\n              color={colors.gray}\n            />\n          </UiEntity>\n          <Button\n            id=\"showcase-default-speaker\"\n            value={isDefaultActive ? 'Active' : 'Turn On'}\n            variant=\"secondary\"\n            disabled={isDefaultActive}\n            fontSize={14}\n            color={colors.white}\n            icon={ICONS.STAR}\n            iconTransform={{\n              ...styles.starIcon,\n              display: isDefaultActive ? 'flex' : 'none',\n            }}\n            iconBackground={{ color: colors.white }}\n            uiTransform={{\n              ...styles.toggleButton,\n              ...(isDefaultActive ? { borderColor: colors.transparent } : {}),\n            }}\n            onMouseDown={() => {\n              if (!isDefaultActive) {\n                onSetDefault();\n              }\n            }}\n          />\n        </UiEntity>\n\n        <UiEntity uiTransform={styles.listContainer}>\n          {participants.length === 0 && (\n            <UiEntity uiTransform={styles.messageContainer}>\n              <Label\n                value=\"No current active participants in the Cast\"\n                fontSize={16}\n                color={colors.gray}\n              />\n            </UiEntity>\n          )}\n          {currentPageParticipants.map(participant => (\n            <ParticipantRow\n              key={participant.identity}\n              participant={participant}\n              activeTrackSid={activeTrackSid}\n              isHovered={hoveredDropdown === participant.identity}\n              onSelectTrack={onSelectTrack}\n              onHoverEnter={() => setHoveredDropdown(participant.identity)}\n              onHoverLeave={() => setHoveredDropdown(undefined)}\n            />\n          ))}\n        </UiEntity>\n      </UiEntity>\n    </Modal>\n  );\n}\n"]}

package/dist/admin-toolkit-ui/VideoControl/DclCast/index.d.ts

@@ -1,11 +1,25 @@
 import ReactEcs from '@dcl/react-ecs';
-import { DeepReadonlyObject, Entity, IEngine, PBVideoPlayer } from '@dcl/ecs';
-import { State } from '../../types';
+import type { DeepReadonlyObject, Entity, IEngine, PBVideoPlayer } from '@dcl/ecs';
+import type { State } from '../../types';
+import { type FlattenedTrack, type Participant } from '../api';
+export declare const showcaseState: {
+    show: boolean;
+    participants: Participant[];
+    activeTrackSid: string | undefined;
+    onSelectTrack: ((track: FlattenedTrack) => void) | undefined;
+    onSetDefault: (() => void) | undefined;
+    onClose: (() => void) | undefined;
+};
+export declare const sharePresentationState: {
+    show: boolean;
+    onClose: (() => void) | undefined;
+};
 export declare function handleGetDclCastInfo(state: State): Promise<import("../api").DclCastResponse | null | undefined>;
-declare const DclCast: ({ engine, state, entity, video, }: {
+declare const DclCast: ({ engine, state, entity, video, playerAddress, }: {
     engine: IEngine;
     state: State;
     entity: Entity;
     video: DeepReadonlyObject<PBVideoPlayer> | undefined;
+    playerAddress: string | undefined;
 }) => ReactEcs.JSX.Element;
 export default DclCast;

package/dist/admin-toolkit-ui/VideoControl/DclCast/index.js

@@ -1,16 +1,41 @@
 import ReactEcs, { UiEntity } from '@dcl/react-ecs';
 import { Color4 } from '@dcl/sdk/math';
-import { getDclCastInfo, resetStreamKey } from '../api';
-import { CONTENT_URL } from '../../constants';
-import { Header } from '../../Header';
-import DclCastInfo from './DclCastInfo';
-import { LoadingDots } from '../../Loading';
+import { getComponents } from '../../../definitions';
+import { getContentUrl } from '../../constants';
+import { setInterval, clearInterval } from '../../utils';
 import { Button } from '../../Button';
+import { LoadingDots } from '../../Loading';
+import { nextTickFunctions } from '../..';
+import { LIVEKIT_STREAM_SRC } from '../LiveStream';
+import { getDclCastInfo, getActiveStreams, groupTracksByParticipant, resetStreamKey, hasPresentationTrack, subscribeToPresentationTopic, consumePresentationMessages, ensurePresenterRole, } from '../api';
+import { createVideoPlayerControls, isDclCast } from '../utils';
+import DclCastInfo from './DclCastInfo';
+import CompactDclCast from './CompactDclCast';
 import { getDclCastStyles, getDclCastColors } from './styles';
-import { getComponents } from '../../../definitions';
 const ICONS = {
-    DCL_CAST_ICON: `${CONTENT_URL}/admin_toolkit/assets/icons/video-control-dcl-cast.png`,
+    get DCL_CAST_ICON() {
+        return `${getContentUrl()}/admin_toolkit/assets/icons/video-control-dcl-cast.png`;
+    },
+    get CHEVRON_UP() {
+        return `${getContentUrl()}/admin_toolkit/assets/icons/chevron-up.png`;
+    },
+};
+export const showcaseState = {
+    show: false,
+    participants: [],
+    activeTrackSid: undefined,
+    onSelectTrack: undefined,
+    onSetDefault: undefined,
+    onClose: undefined,
+};
+export const sharePresentationState = {
+    show: false,
+    onClose: undefined,
 };
+let presentationSubscribed = false;
+let consuming = false;
+let presentationSystem = null;
+let participantPollingSystem = null;
 export async function handleGetDclCastInfo(state) {
     const [error, data] = await getDclCastInfo();
     if (error) {
@@ -24,22 +49,119 @@ export async function handleGetDclCastInfo(state) {
         }
     }
 }
-const DclCast = ({ engine, state, entity, video, }) => {
+function startPresentationSystem(engine, state) {
+    if (presentationSystem)
+        return;
+    presentationSubscribed = true;
+    subscribeToPresentationTopic();
+    const system = () => {
+        if (consuming)
+            return;
+        consuming = true;
+        consumePresentationMessages()
+            .then(latestState => {
+            if (latestState === 'stopped') {
+                state.videoControl.presentationState = undefined;
+            }
+            else if (latestState) {
+                state.videoControl.presentationState = latestState;
+            }
+        })
+            .catch(() => {
+            console.log('[DclCast] Failed to consume presentation messages');
+        })
+            .finally(() => {
+            consuming = false;
+        });
+    };
+    engine.addSystem(system);
+    presentationSystem = system;
+}
+function stopPresentationSystem(engine, state) {
+    if (presentationSystem) {
+        engine.removeSystem(presentationSystem);
+        presentationSystem = null;
+    }
+    state.videoControl.presentationState = undefined;
+    presentationSubscribed = false;
+}
+function startParticipantPolling(engine, state) {
+    if (participantPollingSystem)
+        return;
+    const poll = async () => {
+        const tracks = await getActiveStreams();
+        if (!tracks)
+            return;
+        showcaseState.participants = groupTracksByParticipant(tracks);
+        const hasPresentation = hasPresentationTrack(tracks);
+        if (hasPresentation && !presentationSubscribed) {
+            startPresentationSystem(engine, state);
+        }
+        else if (!hasPresentation && presentationSubscribed) {
+            stopPresentationSystem(engine, state);
+        }
+    };
+    poll();
+    participantPollingSystem = setInterval(engine, poll, 5000);
+}
+function stopParticipantPolling(engine, state) {
+    if (participantPollingSystem) {
+        clearInterval(engine, participantPollingSystem);
+        participantPollingSystem = null;
+    }
+    stopPresentationSystem(engine, state);
+}
+const DclCast = ({ engine, state, entity, video, playerAddress, }) => {
     const { VideoControlState } = getComponents(engine);
+    const controls = createVideoPlayerControls(entity, engine);
     const styles = getDclCastStyles();
     const colors = getDclCastColors();
     const [isLoading, setIsLoading] = ReactEcs.useState(false);
     const [error, setError] = ReactEcs.useState(false);
+    const onShowShowcaseModal = async () => {
+        const latestTracks = await getActiveStreams();
+        if (!latestTracks)
+            return;
+        console.log('[DclCast] Active tracks:', JSON.stringify(latestTracks, null, 2));
+        const closeModal = () => {
+            showcaseState.show = false;
+        };
+        showcaseState.participants = groupTracksByParticipant(latestTracks);
+        showcaseState.onSelectTrack = (track) => {
+            controls.setSource(track.sid);
+            showcaseState.activeTrackSid = track.sid;
+            state.videoControl.selectedStream = 'dcl-cast';
+        };
+        showcaseState.onSetDefault = () => {
+            controls.setSource(LIVEKIT_STREAM_SRC);
+            showcaseState.activeTrackSid = undefined;
+            state.videoControl.selectedStream = 'dcl-cast';
+        };
+        showcaseState.onClose = closeModal;
+        nextTickFunctions.push(() => {
+            showcaseState.show = true;
+        });
+    };
     const fetchDclCastInfo = async () => {
-        console.log('fetching DCL cast info...');
         setIsLoading(true);
         setError(false);
         const result = await handleGetDclCastInfo(state);
         if (!result) {
             setError(true);
         }
+        else if (video?.src?.startsWith('livekit-video://') && !state.videoControl.selectedStream) {
+            state.videoControl.selectedStream = 'dcl-cast';
+        }
         setIsLoading(false);
     };
+    const onSharePresentation = () => {
+        sharePresentationState.onClose = () => {
+            sharePresentationState.show = false;
+        };
+        nextTickFunctions.push(() => {
+            sharePresentationState.show = true;
+        });
+    };
     const handleResetRoomId = async () => {
         setIsLoading(true);
         const [error, data] = await resetStreamKey();
@@ -55,33 +177,84 @@ const DclCast = ({ engine, state, entity, video, }) => {
     };
     ReactEcs.useEffect(() => {
         fetchDclCastInfo();
+        if (playerAddress) {
+            ensurePresenterRole(playerAddress);
+        }
     }, []);
+    const videoSrc = video?.src;
+    ReactEcs.useEffect(() => {
+        if (videoSrc?.startsWith('livekit-video://') && !state.videoControl.selectedStream) {
+            state.videoControl.selectedStream = 'dcl-cast';
+        }
+    }, [videoSrc]);
+    const isCastActive = !!(video?.src && isDclCast(video.src));
+    ReactEcs.useEffect(() => {
+        if (isCastActive) {
+            startParticipantPolling(engine, state);
+        }
+        else {
+            stopParticipantPolling(engine, state);
+        }
+    }, [isCastActive]);
+    ReactEcs.useEffect(() => {
+        if (state.videoControl.presentationState) {
+            state.videoControl.isMinimized = true;
+        }
+    }, [!!state.videoControl.presentationState]);
+    const isMinimized = state.videoControl.isMinimized;
     return (ReactEcs.createElement(UiEntity, { uiTransform: styles.fullContainer },
-        ReactEcs.createElement(Header, { iconSrc: ICONS.DCL_CAST_ICON, title: "DCL Cast" }),
-        ReactEcs.createElement(UiEntity, { uiTransform: styles.fullWidthWithBottomMargin },
-            ReactEcs.createElement(UiEntity, { uiText: {
-                    value: 'Use a browser-based DCL Cast room to easily stream camera and screen feed to a screen in your scene.',
-                    fontSize: 16,
-                    color: Color4.fromHexString('#A09BA8'),
-                    textAlign: 'top-left',
-                    textWrap: 'wrap',
-                }, uiTransform: styles.marginBottomSmall })),
-        isLoading && (ReactEcs.createElement(LoadingDots, { uiTransform: { minHeight: 400 }, engine: engine })),
-        error && (ReactEcs.createElement(UiEntity, { uiTransform: styles.columnCentered },
-            ReactEcs.createElement(UiEntity, { uiText: {
-                    value: '<b>Failed to fetch DCL Cast info</b>',
-                    fontSize: 16,
-                    color: Color4.White(),
-                }, uiTransform: { margin: { bottom: 8 } } }),
-            ReactEcs.createElement(UiEntity, { uiText: {
-                    value: 'Please retry.',
-                    fontSize: 16,
-                    color: Color4.Gray(),
-                } }),
-            ReactEcs.createElement(Button, { id: "dcl_cast_retry", value: "<b>Retry</b>", variant: "secondary", fontSize: 16, color: colors.white, onMouseDown: () => {
-                    handleGetDclCastInfo(state);
-                }, uiTransform: styles.retryButton }))),
-        !isLoading && !error && (ReactEcs.createElement(DclCastInfo, { state: state, entity: entity, engine: engine, video: video, onResetRoomId: handleResetRoomId }))));
+        ReactEcs.createElement(UiEntity, { uiTransform: { display: isMinimized ? 'flex' : 'none', width: '100%' } },
+            ReactEcs.createElement(CompactDclCast, { engine: engine, state: state, entity: entity, video: video, onShowShowcaseModal: onShowShowcaseModal })),
+        ReactEcs.createElement(UiEntity, { uiTransform: {
+                display: isMinimized ? 'none' : 'flex',
+                flexDirection: 'column',
+                width: '100%',
+            } },
+            ReactEcs.createElement(UiEntity, { uiTransform: styles.rowCenterSpaceBetween },
+                ReactEcs.createElement(UiEntity, { uiTransform: styles.rowCenter },
+                    ReactEcs.createElement(UiEntity, { uiTransform: styles.headerIcon, uiBackground: {
+                            textureMode: 'stretch',
+                            texture: { src: ICONS.DCL_CAST_ICON },
+                        } }),
+                    ReactEcs.createElement(UiEntity, { uiText: {
+                            value: '<b>DCL Cast</b>',
+                            fontSize: 24,
+                            color: Color4.White(),
+                            textAlign: 'middle-left',
+                        }, uiTransform: { margin: { left: 10 } } })),
+                ReactEcs.createElement(UiEntity, { onMouseDown: () => {
+                        state.videoControl.isMinimized = true;
+                    }, uiTransform: styles.chevronButton, uiBackground: {
+                        textureMode: 'stretch',
+                        color: Color4.White(),
+                        texture: {
+                            src: ICONS.CHEVRON_UP,
+                        },
+                    } })),
+            ReactEcs.createElement(UiEntity, { uiTransform: styles.fullWidthWithBottomMargin },
+                ReactEcs.createElement(UiEntity, { uiText: {
+                        value: 'Use a browser-based DCL Cast room to easily stream camera and screen feed to a screen in your scene.',
+                        fontSize: 16,
+                        color: Color4.fromHexString('#A09BA8'),
+                        textAlign: 'top-left',
+                        textWrap: 'wrap',
+                    }, uiTransform: styles.marginBottomSmall })),
+            isLoading && (ReactEcs.createElement(LoadingDots, { uiTransform: styles.loadingContainer, engine: engine })),
+            error && (ReactEcs.createElement(UiEntity, { uiTransform: styles.columnCentered },
+                ReactEcs.createElement(UiEntity, { uiText: {
+                        value: '<b>Failed to fetch DCL Cast info</b>',
+                        fontSize: 16,
+                        color: Color4.White(),
+                    }, uiTransform: styles.marginBottomSmall }),
+                ReactEcs.createElement(UiEntity, { uiText: {
+                        value: 'Please retry.',
+                        fontSize: 16,
+                        color: Color4.Gray(),
+                    } }),
+                ReactEcs.createElement(Button, { id: "dcl_cast_retry", value: "<b>Retry</b>", variant: "secondary", fontSize: 16, color: colors.white, onMouseDown: () => {
+                        handleGetDclCastInfo(state);
+                    }, uiTransform: styles.retryButton }))),
+            !isLoading && !error && (ReactEcs.createElement(DclCastInfo, { state: state, entity: entity, engine: engine, video: video, onResetRoomId: handleResetRoomId, onShowShowcaseModal: onShowShowcaseModal, onSharePresentation: onSharePresentation })))));
 };
 export default DclCast;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/admin-toolkit-ui/VideoControl/DclCast/index.tsx"],"names":[],"mappings":"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","sourcesContent":["import ReactEcs, { UiEntity } from '@dcl/react-ecs';\nimport { DeepReadonlyObject, Entity, IEngine, PBVideoPlayer } from '@dcl/ecs';\nimport { Color4 } from '@dcl/sdk/math';\n\nimport { getDclCastInfo, resetStreamKey } from '../api';\nimport { CONTENT_URL } from '../../constants';\nimport { State } from '../../types';\n\nimport { Header } from '../../Header';\nimport DclCastInfo from './DclCastInfo';\nimport { LoadingDots } from '../../Loading';\nimport { Button } from '../../Button';\nimport { getDclCastStyles, getDclCastColors } from './styles';\nimport { getComponents } from '../../../definitions';\n\nconst ICONS = {\n  DCL_CAST_ICON: `${CONTENT_URL}/admin_toolkit/assets/icons/video-control-dcl-cast.png`,\n};\n\nexport async function handleGetDclCastInfo(state: State) {\n  const [error, data] = await getDclCastInfo();\n  if (error) {\n    console.error(error);\n    return null;\n  } else {\n    if (data) {\n      state.videoControl.dclCast = data;\n      return data;\n    }\n  }\n}\n\nconst DclCast = ({\n  engine,\n  state,\n  entity,\n  video,\n}: {\n  engine: IEngine;\n  state: State;\n  entity: Entity;\n  video: DeepReadonlyObject<PBVideoPlayer> | undefined;\n}) => {\n  const { VideoControlState } = getComponents(engine);\n  const styles = getDclCastStyles();\n  const colors = getDclCastColors();\n  const [isLoading, setIsLoading] = ReactEcs.useState(false);\n  const [error, setError] = ReactEcs.useState(false);\n\n  const fetchDclCastInfo = async () => {\n    console.log('fetching DCL cast info...');\n    setIsLoading(true);\n    setError(false);\n\n    const result = await handleGetDclCastInfo(state);\n\n    if (!result) {\n      setError(true);\n    }\n\n    setIsLoading(false);\n  };\n\n  const handleResetRoomId = async () => {\n    setIsLoading(true);\n    const [error, data] = await resetStreamKey();\n    if (error) {\n      setIsLoading(false);\n      setError(true);\n    } else {\n      const videoControl = VideoControlState.getMutable(state.adminToolkitUiEntity);\n      videoControl.endsAt = data?.endsAt;\n      fetchDclCastInfo();\n    }\n  };\n\n  ReactEcs.useEffect(() => {\n    fetchDclCastInfo();\n  }, []);\n\n  return (\n    <UiEntity uiTransform={styles.fullContainer}>\n      <Header\n        iconSrc={ICONS.DCL_CAST_ICON}\n        title=\"DCL Cast\"\n      />\n      <UiEntity uiTransform={styles.fullWidthWithBottomMargin}>\n        <UiEntity\n          uiText={{\n            value:\n              'Use a browser-based DCL Cast room to easily stream camera and screen feed to a screen in your scene.',\n            fontSize: 16,\n            color: Color4.fromHexString('#A09BA8'),\n\n            textAlign: 'top-left',\n            textWrap: 'wrap',\n          }}\n          uiTransform={styles.marginBottomSmall}\n        />\n      </UiEntity>\n      {isLoading && (\n        <LoadingDots\n          uiTransform={{ minHeight: 400 }}\n          engine={engine}\n        />\n      )}\n      {error && (\n        <UiEntity uiTransform={styles.columnCentered}>\n          <UiEntity\n            uiText={{\n              value: '<b>Failed to fetch DCL Cast info</b>',\n              fontSize: 16,\n              color: Color4.White(),\n            }}\n            uiTransform={{ margin: { bottom: 8 } }}\n          />\n          <UiEntity\n            uiText={{\n              value: 'Please retry.',\n              fontSize: 16,\n              color: Color4.Gray(),\n            }}\n          />\n          <Button\n            id=\"dcl_cast_retry\"\n            value=\"<b>Retry</b>\"\n            variant=\"secondary\"\n            fontSize={16}\n            color={colors.white}\n            onMouseDown={() => {\n              handleGetDclCastInfo(state);\n            }}\n            uiTransform={styles.retryButton}\n          />\n        </UiEntity>\n      )}\n\n      {!isLoading && !error && (\n        <DclCastInfo\n          state={state}\n          entity={entity}\n          engine={engine}\n          video={video}\n          onResetRoomId={handleResetRoomId}\n        />\n      )}\n    </UiEntity>\n  );\n};\n\nexport default DclCast;\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/admin-toolkit-ui/VideoControl/DclCast/index.tsx"],"names":[],"mappings":"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","sourcesContent":["import ReactEcs, { UiEntity } from '@dcl/react-ecs';\nimport type { DeepReadonlyObject, Entity, IEngine, PBVideoPlayer } from '@dcl/ecs';\nimport { Color4 } from '@dcl/sdk/math';\nimport { getComponents } from '../../../definitions';\nimport { getContentUrl } from '../../constants';\nimport type { State } from '../../types';\nimport { setInterval, clearInterval } from '../../utils';\nimport { Button } from '../../Button';\nimport { LoadingDots } from '../../Loading';\nimport { nextTickFunctions } from '../..';\nimport { LIVEKIT_STREAM_SRC } from '../LiveStream';\nimport {\n  getDclCastInfo,\n  getActiveStreams,\n  groupTracksByParticipant,\n  resetStreamKey,\n  hasPresentationTrack,\n  subscribeToPresentationTopic,\n  consumePresentationMessages,\n  ensurePresenterRole,\n  type FlattenedTrack,\n  type Participant,\n} from '../api';\nimport { createVideoPlayerControls, isDclCast } from '../utils';\nimport DclCastInfo from './DclCastInfo';\nimport CompactDclCast from './CompactDclCast';\nimport { getDclCastStyles, getDclCastColors } from './styles';\n\nconst ICONS = {\n  get DCL_CAST_ICON() {\n    return `${getContentUrl()}/admin_toolkit/assets/icons/video-control-dcl-cast.png`;\n  },\n  get CHEVRON_UP() {\n    return `${getContentUrl()}/admin_toolkit/assets/icons/chevron-up.png`;\n  },\n};\n\nexport const showcaseState: {\n  show: boolean;\n  participants: Participant[];\n  activeTrackSid: string | undefined;\n  onSelectTrack: ((track: FlattenedTrack) => void) | undefined;\n  onSetDefault: (() => void) | undefined;\n  onClose: (() => void) | undefined;\n} = {\n  show: false,\n  participants: [],\n  activeTrackSid: undefined,\n  onSelectTrack: undefined,\n  onSetDefault: undefined,\n  onClose: undefined,\n};\n\nexport const sharePresentationState: {\n  show: boolean;\n  onClose: (() => void) | undefined;\n} = {\n  show: false,\n  onClose: undefined,\n};\n\nlet presentationSubscribed = false;\nlet consuming = false;\nlet presentationSystem: (() => void) | null = null;\nlet participantPollingSystem: ((dt: number) => void) | null = null;\n\nexport async function handleGetDclCastInfo(state: State) {\n  const [error, data] = await getDclCastInfo();\n  if (error) {\n    console.error(error);\n    return null;\n  } else {\n    if (data) {\n      state.videoControl.dclCast = data;\n      return data;\n    }\n  }\n}\n\nfunction startPresentationSystem(engine: IEngine, state: State): void {\n  if (presentationSystem) return; // Already running\n  presentationSubscribed = true;\n  subscribeToPresentationTopic();\n\n  const system = () => {\n    if (consuming) return; // Prevent concurrent requests\n    consuming = true;\n    consumePresentationMessages()\n      .then(latestState => {\n        if (latestState === 'stopped') {\n          state.videoControl.presentationState = undefined;\n        } else if (latestState) {\n          state.videoControl.presentationState = latestState;\n        }\n      })\n      .catch(() => {\n        // Silently ignore — will retry next frame\n        console.log('[DclCast] Failed to consume presentation messages');\n      })\n      .finally(() => {\n        consuming = false;\n      });\n  };\n\n  engine.addSystem(system);\n  presentationSystem = system;\n}\n\nfunction stopPresentationSystem(engine: IEngine, state: State): void {\n  if (presentationSystem) {\n    engine.removeSystem(presentationSystem);\n    presentationSystem = null;\n  }\n  state.videoControl.presentationState = undefined;\n  presentationSubscribed = false;\n}\n\nfunction startParticipantPolling(engine: IEngine, state: State): void {\n  if (participantPollingSystem) return; // Already polling\n\n  const poll = async () => {\n    const tracks = await getActiveStreams();\n    if (!tracks) return;\n\n    // Debug: log tracks on each poll to review presentation bot metadata\n    // console.log('[DclCast] Poll tracks:', JSON.stringify(tracks, null, 2));\n\n    // Keep showcase modal data fresh\n    showcaseState.participants = groupTracksByParticipant(tracks);\n\n    // Check for presentation track\n    const hasPresentation = hasPresentationTrack(tracks);\n\n    // console.log(`[DclCast] Presentation track ${hasPresentation ? 'found' : 'not found'} in poll`);\n\n    if (hasPresentation && !presentationSubscribed) {\n      startPresentationSystem(engine, state);\n    } else if (!hasPresentation && presentationSubscribed) {\n      stopPresentationSystem(engine, state);\n    }\n  };\n\n  // Poll immediately, then every 5 seconds\n  poll();\n  participantPollingSystem = setInterval(engine, poll, 5000);\n}\n\nfunction stopParticipantPolling(engine: IEngine, state: State): void {\n  if (participantPollingSystem) {\n    clearInterval(engine, participantPollingSystem);\n    participantPollingSystem = null;\n  }\n  stopPresentationSystem(engine, state);\n}\n\nconst DclCast = ({\n  engine,\n  state,\n  entity,\n  video,\n  playerAddress,\n}: {\n  engine: IEngine;\n  state: State;\n  entity: Entity;\n  video: DeepReadonlyObject<PBVideoPlayer> | undefined;\n  playerAddress: string | undefined;\n}) => {\n  const { VideoControlState } = getComponents(engine);\n  const controls = createVideoPlayerControls(entity, engine);\n  const styles = getDclCastStyles();\n  const colors = getDclCastColors();\n  const [isLoading, setIsLoading] = ReactEcs.useState(false);\n  const [error, setError] = ReactEcs.useState(false);\n\n  const onShowShowcaseModal = async () => {\n    const latestTracks = await getActiveStreams();\n    if (!latestTracks) return;\n\n    // Debug: log all track data to review presentation bot metadata\n    console.log('[DclCast] Active tracks:', JSON.stringify(latestTracks, null, 2));\n\n    const closeModal = () => {\n      showcaseState.show = false;\n    };\n\n    showcaseState.participants = groupTracksByParticipant(latestTracks);\n\n    showcaseState.onSelectTrack = (track: FlattenedTrack) => {\n      controls.setSource(track.sid);\n      showcaseState.activeTrackSid = track.sid;\n      state.videoControl.selectedStream = 'dcl-cast';\n    };\n\n    showcaseState.onSetDefault = () => {\n      controls.setSource(LIVEKIT_STREAM_SRC);\n      showcaseState.activeTrackSid = undefined;\n      state.videoControl.selectedStream = 'dcl-cast';\n    };\n\n    showcaseState.onClose = closeModal;\n\n    nextTickFunctions.push(() => {\n      showcaseState.show = true;\n    });\n  };\n\n  const fetchDclCastInfo = async () => {\n    setIsLoading(true);\n    setError(false);\n\n    const result = await handleGetDclCastInfo(state);\n\n    if (!result) {\n      setError(true);\n    } else if (video?.src?.startsWith('livekit-video://') && !state.videoControl.selectedStream) {\n      state.videoControl.selectedStream = 'dcl-cast';\n    }\n\n    setIsLoading(false);\n  };\n\n  const onSharePresentation = () => {\n    sharePresentationState.onClose = () => {\n      sharePresentationState.show = false;\n    };\n    nextTickFunctions.push(() => {\n      sharePresentationState.show = true;\n    });\n  };\n\n  const handleResetRoomId = async () => {\n    setIsLoading(true);\n    const [error, data] = await resetStreamKey();\n    if (error) {\n      setIsLoading(false);\n      setError(true);\n    } else {\n      const videoControl = VideoControlState.getMutable(state.adminToolkitUiEntity);\n      videoControl.endsAt = data?.endsAt;\n      fetchDclCastInfo();\n    }\n  };\n\n  ReactEcs.useEffect(() => {\n    fetchDclCastInfo();\n    if (playerAddress) {\n      ensurePresenterRole(playerAddress);\n    }\n  }, []);\n\n  // Sync selectedStream when video.src arrives after mount (late-joiner fix)\n  const videoSrc = video?.src;\n  ReactEcs.useEffect(() => {\n    if (videoSrc?.startsWith('livekit-video://') && !state.videoControl.selectedStream) {\n      state.videoControl.selectedStream = 'dcl-cast';\n    }\n  }, [videoSrc]);\n\n  const isCastActive = !!(video?.src && isDclCast(video.src));\n\n  ReactEcs.useEffect(() => {\n    if (isCastActive) {\n      startParticipantPolling(engine, state);\n    } else {\n      stopParticipantPolling(engine, state);\n    }\n  }, [isCastActive]);\n\n  // Auto-minimize when a presentation starts so the compact view\n  // (with presentation controls) is immediately visible\n  ReactEcs.useEffect(() => {\n    if (state.videoControl.presentationState) {\n      state.videoControl.isMinimized = true;\n    }\n  }, [!!state.videoControl.presentationState]);\n\n  const isMinimized = state.videoControl.isMinimized;\n\n  return (\n    <UiEntity uiTransform={styles.fullContainer}>\n      {/* Compact bar — always rendered, toggled via display */}\n      <UiEntity uiTransform={{ display: isMinimized ? 'flex' : 'none', width: '100%' }}>\n        <CompactDclCast\n          engine={engine}\n          state={state}\n          entity={entity}\n          video={video}\n          onShowShowcaseModal={onShowShowcaseModal}\n        />\n      </UiEntity>\n\n      {/* Full panel — always rendered, toggled via display */}\n      <UiEntity\n        uiTransform={{\n          display: isMinimized ? 'none' : 'flex',\n          flexDirection: 'column',\n          width: '100%',\n        }}\n      >\n        <UiEntity uiTransform={styles.rowCenterSpaceBetween}>\n          <UiEntity uiTransform={styles.rowCenter}>\n            <UiEntity\n              uiTransform={styles.headerIcon}\n              uiBackground={{\n                textureMode: 'stretch',\n                texture: { src: ICONS.DCL_CAST_ICON },\n              }}\n            />\n            <UiEntity\n              uiText={{\n                value: '<b>DCL Cast</b>',\n                fontSize: 24,\n                color: Color4.White(),\n                textAlign: 'middle-left',\n              }}\n              uiTransform={{ margin: { left: 10 } }}\n            />\n          </UiEntity>\n          <UiEntity\n            onMouseDown={() => {\n              state.videoControl.isMinimized = true;\n            }}\n            uiTransform={styles.chevronButton}\n            uiBackground={{\n              textureMode: 'stretch',\n              color: Color4.White(),\n              texture: {\n                src: ICONS.CHEVRON_UP,\n              },\n            }}\n          />\n        </UiEntity>\n        <UiEntity uiTransform={styles.fullWidthWithBottomMargin}>\n          <UiEntity\n            uiText={{\n              value:\n                'Use a browser-based DCL Cast room to easily stream camera and screen feed to a screen in your scene.',\n              fontSize: 16,\n              color: Color4.fromHexString('#A09BA8'),\n\n              textAlign: 'top-left',\n              textWrap: 'wrap',\n            }}\n            uiTransform={styles.marginBottomSmall}\n          />\n        </UiEntity>\n        {isLoading && (\n          <LoadingDots\n            uiTransform={styles.loadingContainer}\n            engine={engine}\n          />\n        )}\n        {error && (\n          <UiEntity uiTransform={styles.columnCentered}>\n            <UiEntity\n              uiText={{\n                value: '<b>Failed to fetch DCL Cast info</b>',\n                fontSize: 16,\n                color: Color4.White(),\n              }}\n              uiTransform={styles.marginBottomSmall}\n            />\n            <UiEntity\n              uiText={{\n                value: 'Please retry.',\n                fontSize: 16,\n                color: Color4.Gray(),\n              }}\n            />\n            <Button\n              id=\"dcl_cast_retry\"\n              value=\"<b>Retry</b>\"\n              variant=\"secondary\"\n              fontSize={16}\n              color={colors.white}\n              onMouseDown={() => {\n                handleGetDclCastInfo(state);\n              }}\n              uiTransform={styles.retryButton}\n            />\n          </UiEntity>\n        )}\n\n        {!isLoading && !error && (\n          <DclCastInfo\n            state={state}\n            entity={entity}\n            engine={engine}\n            video={video}\n            onResetRoomId={handleResetRoomId}\n            onShowShowcaseModal={onShowShowcaseModal}\n            onSharePresentation={onSharePresentation}\n          />\n        )}\n      </UiEntity>\n    </UiEntity>\n  );\n};\n\nexport default DclCast;\n"]}

package/dist/admin-toolkit-ui/VideoControl/DclCast/styles.d.ts

@@ -1,5 +1,6 @@
 import { Color4 } from '@dcl/sdk/math';
-import { UiTransformProps } from '@dcl/react-ecs';
+import type { UiTransformProps } from '@dcl/react-ecs';
+import { getPaginationColor } from '../../ModerationControl/styles/UsersListStyles';
 export declare const getDclCastStyles: () => Record<string, UiTransformProps>;
 export declare const getDclCastColors: () => {
     white: Color4.MutableColor4;
@@ -18,3 +19,74 @@ export declare const getDclCastBackgrounds: () => {
         textureMode: "stretch";
     };
 };
+export declare const getCompactBarStyles: () => Record<string, UiTransformProps>;
+export declare const SHOWCASE_DROPDOWN_COLORS: {
+    idle: Color4.MutableColor4;
+    hover: Color4.MutableColor4;
+    active: Color4.MutableColor4;
+    hoverBg: Color4.MutableColor4;
+    transparentBg: Color4.MutableColor4;
+};
+export declare const SHOWCASE_PAGE_INDICATOR_COLOR: Color4.MutableColor4;
+export declare const getSpeakerShowcaseStyles: () => Record<string, UiTransformProps>;
+export declare const getShowcaseColors: () => {
+    white: Color4.MutableColor4;
+    gray: Color4.MutableColor4;
+    addressGray: Color4.MutableColor4;
+    removeRed: Color4.MutableColor4;
+    disabledGray: Color4.MutableColor4;
+    black: Color4.MutableColor4;
+    softBlack: Color4.MutableColor4;
+    transparent: Color4.MutableColor4;
+};
+export declare function getShowcaseIconBackgrounds(): {
+    showcase: {
+        textureMode: "stretch";
+        texture: {
+            src: string;
+        };
+    };
+    star: {
+        textureMode: "stretch";
+        texture: {
+            src: string;
+        };
+    };
+};
+export declare function getShowcaseBackgrounds(): {
+    container: {
+        color: Color4.MutableColor4;
+    };
+    divider: {
+        color: Color4.MutableColor4;
+    };
+    roleBadge: {
+        color: Color4.MutableColor4;
+    };
+    headerIcon: {
+        textureMode: "stretch";
+        texture: {
+            src: string;
+        };
+    };
+    personIcon: {
+        textureMode: "stretch";
+        texture: {
+            src: string;
+        };
+    };
+    banIcon: {
+        textureMode: "stretch";
+        texture: {
+            src: string;
+        };
+    };
+    verifiedIcon: {
+        textureMode: "stretch";
+        texture: {
+            src: string;
+        };
+        color: Color4.MutableColor4;
+    };
+};
+export { getPaginationColor };