@dcl/asset-packs 2.3.1 → 2.4.0

package/dist/admin-toolkit-ui/VideoControl/api.d.ts

@@ -0,0 +1,12 @@
+import { Result } from "../fetch-utils";
+type StreamKeyResponse = {
+    streamingUrl: string;
+    streamingKey: string;
+    createdAt: number;
+    endsAt: number;
+};
+export declare function getStreamKey(): Promise<Result<StreamKeyResponse, string>>;
+export declare function generateStreamKey(): Promise<Result<StreamKeyResponse, string>>;
+export declare function revokeStreamKey(): Promise<Result<StreamKeyResponse, string>>;
+export declare function resetStreamKey(): Promise<Result<StreamKeyResponse, string>>;
+export {};

package/dist/admin-toolkit-ui/VideoControl/api.js

@@ -0,0 +1,17 @@
+import { getDomain, wrapSignedFetch } from "../fetch-utils";
+const URLS = () => ({
+    STREAM_KEY: `https://comms-gatekeeper.decentraland.${getDomain()}/scene-stream-access`,
+});
+export async function getStreamKey() {
+    return wrapSignedFetch({ url: URLS().STREAM_KEY }, { toCamelCase: true });
+}
+export async function generateStreamKey() {
+    return wrapSignedFetch({ url: URLS().STREAM_KEY, init: { method: 'POST', headers: {} } }, { toCamelCase: true });
+}
+export async function revokeStreamKey() {
+    return wrapSignedFetch({ url: URLS().STREAM_KEY, init: { method: 'DELETE', headers: {} } });
+}
+export async function resetStreamKey() {
+    return wrapSignedFetch({ url: URLS().STREAM_KEY, init: { method: 'PUT', headers: {} } }, { toCamelCase: true });
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,28 @@
+import { IEngine } from '@dcl/ecs';
+import ReactEcs from '@dcl/react-ecs';
+import { Color4 } from '@dcl/sdk/math';
+import { State } from '../types';
+export declare const ICONS: {
+    readonly VIDEO_CONTROL: "https://builder-items.decentraland.org/admin_toolkit/assets/icons/video-control.png";
+    readonly PREVIOUS_BUTTON: "https://builder-items.decentraland.org/admin_toolkit/assets/icons/video-control-previous-button.png";
+    readonly FORWARD_BUTTON: "https://builder-items.decentraland.org/admin_toolkit/assets/icons/video-control-forward-button.png";
+    readonly PLAY_BUTTON: "https://builder-items.decentraland.org/admin_toolkit/assets/icons/video-control-play-button.png";
+    readonly MUTE: "https://builder-items.decentraland.org/admin_toolkit/assets/icons/video-control-mute.png";
+    readonly LOOP: "https://builder-items.decentraland.org/admin_toolkit/assets/icons/video-control-loop.png";
+    readonly VOLUME_MINUS_BUTTON: "https://builder-items.decentraland.org/admin_toolkit/assets/icons/video-control-volume-minus-button.png";
+    readonly VOLUME_PLUS_BUTTON: "https://builder-items.decentraland.org/admin_toolkit/assets/icons/video-control-volume-plus-button.png";
+    readonly VIDEO_SOURCE: "https://builder-items.decentraland.org/admin_toolkit/assets/icons/video-control-video.png";
+    readonly LIVE_SOURCE: "https://builder-items.decentraland.org/admin_toolkit/assets/icons/video-control-live.png";
+    readonly INFO: "https://builder-items.decentraland.org/admin_toolkit/assets/icons/info.png";
+};
+export declare const VOLUME_STEP = 0.1;
+export declare const DEFAULT_VOLUME = 1;
+export declare const COLORS: {
+    readonly WHITE: Color4.MutableColor4;
+    readonly GRAY: Color4.MutableColor4;
+    readonly SUCCESS: Color4.MutableColor4;
+};
+export declare function VideoControl({ engine, state, }: {
+    engine: IEngine;
+    state: State;
+}): ReactEcs.JSX.Element;

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

@@ -0,0 +1,107 @@
+import ReactEcs, { Label, UiEntity, Dropdown } from '@dcl/react-ecs';
+import { Color4 } from '@dcl/sdk/math';
+import { getScaleUIFactor } from '../../ui';
+import { Button } from '../Button';
+import { CONTENT_URL } from '../constants';
+import { Header } from '../Header';
+import { getVideoPlayers, useSelectedVideoPlayer } from './utils';
+import { Card } from '../Card';
+import { VideoControlURL } from './VideoUrl';
+import { LiveStream } from './LiveStream';
+import { Active } from '../Active';
+import { LIVEKIT_STREAM_SRC } from '../../definitions';
+export const ICONS = {
+    VIDEO_CONTROL: `${CONTENT_URL}/admin_toolkit/assets/icons/video-control.png`,
+    PREVIOUS_BUTTON: `${CONTENT_URL}/admin_toolkit/assets/icons/video-control-previous-button.png`,
+    FORWARD_BUTTON: `${CONTENT_URL}/admin_toolkit/assets/icons/video-control-forward-button.png`,
+    PLAY_BUTTON: `${CONTENT_URL}/admin_toolkit/assets/icons/video-control-play-button.png`,
+    MUTE: `${CONTENT_URL}/admin_toolkit/assets/icons/video-control-mute.png`,
+    LOOP: `${CONTENT_URL}/admin_toolkit/assets/icons/video-control-loop.png`,
+    VOLUME_MINUS_BUTTON: `${CONTENT_URL}/admin_toolkit/assets/icons/video-control-volume-minus-button.png`,
+    VOLUME_PLUS_BUTTON: `${CONTENT_URL}/admin_toolkit/assets/icons/video-control-volume-plus-button.png`,
+    VIDEO_SOURCE: `${CONTENT_URL}/admin_toolkit/assets/icons/video-control-video.png`,
+    LIVE_SOURCE: `${CONTENT_URL}/admin_toolkit/assets/icons/video-control-live.png`,
+    INFO: `${CONTENT_URL}/admin_toolkit/assets/icons/info.png`,
+};
+export const VOLUME_STEP = 0.1;
+export const DEFAULT_VOLUME = 1;
+export const COLORS = {
+    WHITE: Color4.White(),
+    GRAY: Color4.create(160 / 255, 155 / 255, 168 / 255, 1),
+    SUCCESS: Color4.fromHexString('#34CE77'),
+};
+export function VideoControl({ engine, state, }) {
+    const [selectedEntity, selectedVideo] = useSelectedVideoPlayer(engine) ?? [];
+    const scaleFactor = getScaleUIFactor(engine);
+    const videoPlayers = getVideoPlayers(engine);
+    const [selected, setSelected] = ReactEcs.useState(undefined);
+    ReactEcs.useEffect(() => {
+        setSelected(selectedVideo && selectedVideo.src.startsWith('https://')
+            ? 'video-url'
+            : 'live');
+    }, [state.videoControl.selectedVideoPlayer]);
+    return (ReactEcs.createElement(UiEntity, { uiTransform: { flexDirection: 'column', width: '100%', height: '100%' } },
+        ReactEcs.createElement(Card, { scaleFactor: scaleFactor, uiTransform: {
+                padding: {
+                    top: 32 * scaleFactor,
+                    right: 32 * scaleFactor,
+                    bottom: 0,
+                    left: 32 * scaleFactor,
+                },
+            } },
+            ReactEcs.createElement(UiEntity, { uiTransform: {
+                    width: '100%',
+                    height: '100%',
+                    flexDirection: 'column',
+                } },
+                ReactEcs.createElement(Header, { iconSrc: ICONS.VIDEO_CONTROL, title: "<b>VIDEO SCREENS</b>", scaleFactor: scaleFactor }),
+                videoPlayers.length > 1 && ReactEcs.createElement(Label, { value: "<b>Current Screen</b>", fontSize: 16 * scaleFactor, color: Color4.White(), uiTransform: { margin: { bottom: 16 * scaleFactor } } }),
+                ReactEcs.createElement(UiEntity, { uiTransform: {
+                        flexDirection: 'column',
+                        margin: { bottom: 16 * scaleFactor },
+                    } },
+                    videoPlayers.length > 1 && (ReactEcs.createElement(UiEntity, { uiTransform: { flexDirection: 'column' } },
+                        ReactEcs.createElement(Dropdown, { options: videoPlayers.map((player) => `<b>${player.customName}</b>`), selectedIndex: state.videoControl.selectedVideoPlayer ?? 0, onChange: (idx) => (state.videoControl.selectedVideoPlayer = idx), textAlign: "middle-left", fontSize: 16 * scaleFactor, uiTransform: {
+                                margin: { right: 8 * scaleFactor },
+                                width: '100%',
+                            }, uiBackground: { color: Color4.White() } }))),
+                    ReactEcs.createElement(Label, { fontSize: 16 * scaleFactor, value: "<b>Media Source</b>", color: Color4.White(), uiTransform: { margin: { bottom: 2 * scaleFactor, top: 16 * scaleFactor } } }),
+                    ReactEcs.createElement(UiEntity, { uiTransform: {
+                            margin: { top: 10 * scaleFactor },
+                            flexDirection: 'row',
+                            width: '100%',
+                        } },
+                        ReactEcs.createElement(UiEntity, { uiTransform: { width: '50%', padding: { right: 8 * scaleFactor } } },
+                            ReactEcs.createElement(CustomButton, { engine: engine, id: "video_control_url", value: "<b>VIDEO URL</b>", icon: ICONS.VIDEO_SOURCE, onClick: () => setSelected('video-url'), scaleFactor: scaleFactor, selected: selected === 'video-url', active: selectedVideo && selectedVideo.src.startsWith('https://') })),
+                        ReactEcs.createElement(UiEntity, { uiTransform: { width: '50%', padding: { left: 8 * scaleFactor } } },
+                            ReactEcs.createElement(CustomButton, { engine: engine, id: "video_control_live", value: "<b>LIVE STREAM</b>", icon: ICONS.LIVE_SOURCE, onClick: () => setSelected('live'), active: selectedVideo &&
+                                    selectedVideo.src.startsWith(LIVEKIT_STREAM_SRC), scaleFactor: scaleFactor, selected: selected === 'live' })))))),
+        selected && selectedEntity && (ReactEcs.createElement(Card, { scaleFactor: scaleFactor },
+            selected === 'video-url' && (ReactEcs.createElement(VideoControlURL, { engine: engine, scaleFactor: scaleFactor, entity: selectedEntity, video: selectedVideo })),
+            selected === 'live' && (ReactEcs.createElement(LiveStream, { engine: engine, scaleFactor: scaleFactor, entity: selectedEntity, video: selectedVideo }))))));
+}
+function CustomButton({ active, scaleFactor, value, id, onClick, icon, selected, engine }) {
+    return (ReactEcs.createElement(UiEntity, { uiTransform: { flexDirection: 'column', height: '100%', width: '100%' } },
+        ReactEcs.createElement(UiEntity, { uiTransform: { width: '100%' } },
+            ReactEcs.createElement(Button, { id: id, onMouseDown: onClick, value: value, fontSize: 14 * scaleFactor, icon: icon, iconTransform: {
+                    width: 24 * scaleFactor,
+                    height: 24 * scaleFactor,
+                    margin: { right: 8 * scaleFactor },
+                }, color: selected ? Color4.Black() : Color4.fromHexString('#FCFCFC'), iconBackground: {
+                    color: selected ? Color4.Black() : Color4.fromHexString('#FCFCFC'),
+                }, uiBackground: {
+                    color: selected ? Color4.White() : Color4.fromHexString('#43404A'),
+                }, uiTransform: {
+                    padding: {
+                        top: 6 * scaleFactor,
+                        bottom: 6 * scaleFactor,
+                    },
+                    borderRadius: 6 * scaleFactor,
+                    alignItems: 'center',
+                    justifyContent: 'center',
+                    width: '100%',
+                    height: 36 * scaleFactor
+                } })),
+        active && ReactEcs.createElement(Active, { scaleFactor: scaleFactor, engine: engine, uiTransform: { width: '100%', margin: { top: 6 * scaleFactor } } })));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/admin-toolkit-ui/VideoControl/index.tsx"],"names":[],"mappings":"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","sourcesContent":["import { IEngine } from '@dcl/ecs'\nimport ReactEcs, { Label, UiEntity, Dropdown } from '@dcl/react-ecs'\nimport { Color4 } from '@dcl/sdk/math'\nimport { getScaleUIFactor } from '../../ui'\nimport { Button } from '../Button'\nimport { CONTENT_URL } from '../constants'\nimport { State } from '../types'\nimport { Header } from '../Header'\nimport { getVideoPlayers, useSelectedVideoPlayer } from './utils'\nimport { Card } from '../Card'\nimport { VideoControlURL } from './VideoUrl'\nimport { LiveStream } from './LiveStream'\nimport { Active } from '../Active'\nimport { LIVEKIT_STREAM_SRC } from '../../definitions'\n\n// Constants\nexport const ICONS = {\n  VIDEO_CONTROL: `${CONTENT_URL}/admin_toolkit/assets/icons/video-control.png`,\n  PREVIOUS_BUTTON: `${CONTENT_URL}/admin_toolkit/assets/icons/video-control-previous-button.png`,\n  FORWARD_BUTTON: `${CONTENT_URL}/admin_toolkit/assets/icons/video-control-forward-button.png`,\n  PLAY_BUTTON: `${CONTENT_URL}/admin_toolkit/assets/icons/video-control-play-button.png`,\n  MUTE: `${CONTENT_URL}/admin_toolkit/assets/icons/video-control-mute.png`,\n  LOOP: `${CONTENT_URL}/admin_toolkit/assets/icons/video-control-loop.png`,\n  VOLUME_MINUS_BUTTON: `${CONTENT_URL}/admin_toolkit/assets/icons/video-control-volume-minus-button.png`,\n  VOLUME_PLUS_BUTTON: `${CONTENT_URL}/admin_toolkit/assets/icons/video-control-volume-plus-button.png`,\n  VIDEO_SOURCE: `${CONTENT_URL}/admin_toolkit/assets/icons/video-control-video.png`,\n  LIVE_SOURCE: `${CONTENT_URL}/admin_toolkit/assets/icons/video-control-live.png`,\n  INFO: `${CONTENT_URL}/admin_toolkit/assets/icons/info.png`,\n} as const\n\n\nexport const VOLUME_STEP = 0.1\nexport const DEFAULT_VOLUME = 1\n\nexport const COLORS = {\n  WHITE: Color4.White(),\n  GRAY: Color4.create(160 / 255, 155 / 255, 168 / 255, 1),\n  SUCCESS: Color4.fromHexString('#34CE77'),\n} as const\n\n\n// Main component\nexport function VideoControl({\n  engine,\n  state,\n}: {\n  engine: IEngine\n  state: State\n}) {\n  const [selectedEntity, selectedVideo] = useSelectedVideoPlayer(engine) ?? []\n  const scaleFactor = getScaleUIFactor(engine)\n  const videoPlayers = getVideoPlayers(engine)\n  const [selected, setSelected] = ReactEcs.useState<'video-url' | 'live' | undefined>(undefined)\n\n  ReactEcs.useEffect(() => {\n    setSelected(\n      selectedVideo && selectedVideo.src.startsWith('https://')\n        ? 'video-url'\n        : 'live',\n    )\n  }, [state.videoControl.selectedVideoPlayer])\n\n  return (\n    <UiEntity\n      uiTransform={{ flexDirection: 'column', width: '100%', height: '100%' }}\n    >\n      <Card\n        scaleFactor={scaleFactor}\n        uiTransform={{\n          padding: {\n            top: 32 * scaleFactor,\n            right: 32 * scaleFactor,\n            bottom: 0,\n            left: 32 * scaleFactor,\n          },\n        }}\n      >\n        <UiEntity\n          uiTransform={{\n            width: '100%',\n            height: '100%',\n            flexDirection: 'column',\n          }}\n        >\n          {/* Header */}\n          <Header\n            iconSrc={ICONS.VIDEO_CONTROL}\n            title=\"<b>VIDEO SCREENS</b>\"\n            scaleFactor={scaleFactor}\n          />\n          {videoPlayers.length > 1 && <Label\n            value=\"<b>Current Screen</b>\"\n            fontSize={16 * scaleFactor}\n            color={Color4.White()}\n            uiTransform={{ margin: { bottom: 16 * scaleFactor } }}\n          />}\n\n          <UiEntity\n            uiTransform={{\n              flexDirection: 'column',\n              margin: { bottom: 16 * scaleFactor },\n            }}\n          >\n            {videoPlayers.length > 1 && (\n              <UiEntity uiTransform={{ flexDirection: 'column' }}>\n                <Dropdown\n                  options={videoPlayers.map(\n                    (player) => `<b>${player.customName}</b>`,\n                  )}\n                  selectedIndex={state.videoControl.selectedVideoPlayer ?? 0}\n                  onChange={(idx) =>\n                    (state.videoControl.selectedVideoPlayer = idx)\n                  }\n                  textAlign=\"middle-left\"\n                  fontSize={16 * scaleFactor}\n                  uiTransform={{\n                    margin: { right: 8 * scaleFactor },\n                    width: '100%',\n                  }}\n                  uiBackground={{ color: Color4.White() }}\n                />\n              </UiEntity>\n            )}\n            <Label\n              fontSize={16 * scaleFactor}\n              value=\"<b>Media Source</b>\"\n              color={Color4.White()}\n              uiTransform={{ margin: { bottom: 2 * scaleFactor, top: 16 * scaleFactor } }}\n            />\n            <UiEntity\n              uiTransform={{\n                margin: { top: 10 * scaleFactor },\n                flexDirection: 'row',\n                width: '100%',\n              }}\n            >\n              <UiEntity uiTransform={{ width: '50%', padding: { right: 8 * scaleFactor } }}>\n                <CustomButton\n                  engine={engine}\n                  id=\"video_control_url\"\n                  value=\"<b>VIDEO URL</b>\"\n                  icon={ICONS.VIDEO_SOURCE}\n                  onClick={() => setSelected('video-url')}\n                  scaleFactor={scaleFactor}\n                  selected={selected === 'video-url'}\n                  active={\n                    selectedVideo && selectedVideo.src.startsWith('https://')\n                  }\n                />\n              </UiEntity>\n              <UiEntity uiTransform={{ width: '50%', padding: { left: 8 * scaleFactor } }}>\n                <CustomButton\n                  engine={engine}\n                  id=\"video_control_live\"\n                  value=\"<b>LIVE STREAM</b>\"\n                  icon={ICONS.LIVE_SOURCE}\n                  onClick={() => setSelected('live')}\n                  active={\n                    selectedVideo &&\n                    selectedVideo.src.startsWith(LIVEKIT_STREAM_SRC)\n                  }\n                  scaleFactor={scaleFactor}\n                  selected={selected === 'live'}\n                />\n              </UiEntity>\n            </UiEntity>\n          </UiEntity>\n        </UiEntity>\n      </Card>\n      {selected && selectedEntity && (\n        <Card scaleFactor={scaleFactor}>\n          {selected === 'video-url' && (\n            <VideoControlURL\n              engine={engine}\n              scaleFactor={scaleFactor}\n              entity={selectedEntity}\n              video={selectedVideo}\n            />\n          )}\n          {selected === 'live' && (\n            <LiveStream\n              engine={engine}\n              scaleFactor={scaleFactor}\n              entity={selectedEntity}\n              video={selectedVideo}\n            />\n          )}\n        </Card>\n      )}\n    </UiEntity>\n  )\n}\n\n\ninterface Props {\n  id: string\n  value: string\n  onClick(): void\n  selected: boolean\n  scaleFactor: number\n  icon: string\n  engine: IEngine\n  active?: boolean\n}\n\nfunction CustomButton({ active, scaleFactor, value, id, onClick, icon, selected, engine }: Props) {\n  return (\n    <UiEntity\n      uiTransform={{ flexDirection: 'column', height: '100%', width: '100%' }}\n    >\n      <UiEntity uiTransform={{ width: '100%' }}>\n        <Button\n          id={id}\n          onMouseDown={onClick}\n          value={value}\n          fontSize={14 * scaleFactor}\n          icon={icon}\n          iconTransform={{\n            width: 24 * scaleFactor,\n            height: 24 * scaleFactor,\n            margin: { right: 8 * scaleFactor },\n          }}\n          color={selected ? Color4.Black() : Color4.fromHexString('#FCFCFC')}\n          iconBackground={{\n            color: selected ? Color4.Black() : Color4.fromHexString('#FCFCFC'),\n          }}\n          uiBackground={{\n            color: selected ? Color4.White() : Color4.fromHexString('#43404A'),\n          }}\n          uiTransform={{\n            padding: {\n              top: 6 * scaleFactor,\n              bottom: 6 * scaleFactor,\n            },\n            borderRadius: 6 * scaleFactor,\n            alignItems: 'center',\n            justifyContent: 'center',\n            width: '100%',\n            height: 36 * scaleFactor\n          }}\n        />\n      </UiEntity>\n\n      {active && <Active scaleFactor={scaleFactor} engine={engine} uiTransform={{ width: '100%', margin: { top: 6 * scaleFactor } }} />}\n    </UiEntity>\n  )\n}"]}

package/dist/admin-toolkit-ui/VideoControl/utils.d.ts

@@ -0,0 +1,28 @@
+import { DeepReadonlyObject, Entity, IEngine, PBVideoPlayer } from '@dcl/ecs';
+interface VideoPlayerControls {
+    play(): void;
+    pause(): void;
+    restart(): void;
+    previous(): void;
+    next(): void;
+    setVolume(volume: number): void;
+    setSource(url: string): void;
+    setLoop(loop: boolean): void;
+}
+export declare function getAdminToolkitVideoControl(engine: IEngine): DeepReadonlyObject<import("@dcl/ecs").MapResult<{
+    isEnabled: import("@dcl/ecs").ISchema<boolean>;
+    disableVideoPlayersSound: import("@dcl/ecs").ISchema<boolean>;
+    showAuthorOnVideoPlayers: import("@dcl/ecs").ISchema<boolean>;
+    linkAllVideoPlayers: import("@dcl/ecs").ISchema<boolean>;
+    videoPlayers: import("@dcl/ecs").ISchema<import("@dcl/ecs").MapResult<{
+        entity: import("@dcl/ecs").ISchema<number>;
+        customName: import("@dcl/ecs").ISchema<string>;
+    }>[] | undefined>;
+}>> | null;
+export declare function getVideoPlayers(engine: IEngine): DeepReadonlyObject<import("@dcl/ecs").MapResult<{
+    entity: import("@dcl/ecs").ISchema<number>;
+    customName: import("@dcl/ecs").ISchema<string>;
+}>>[];
+export declare function createVideoPlayerControls(entity: Entity, engine: IEngine): VideoPlayerControls;
+export declare function useSelectedVideoPlayer(engine: IEngine): [Entity, DeepReadonlyObject<PBVideoPlayer>] | null;
+export {};

package/dist/admin-toolkit-ui/VideoControl/utils.js

@@ -0,0 +1,87 @@
+import { getComponents } from '../../definitions';
+import { getExplorerComponents } from '../../components';
+import { nextTickFunctions, state } from '../index';
+import { DEFAULT_VOLUME } from '.';
+export function getAdminToolkitVideoControl(engine) {
+    const { AdminTools } = getComponents(engine);
+    const adminToolkitEntities = Array.from(engine.getEntitiesWith(AdminTools));
+    return adminToolkitEntities.length > 0
+        ? adminToolkitEntities[0][1].videoControl
+        : null;
+}
+export function getVideoPlayers(engine) {
+    const adminToolkitVideoControl = getAdminToolkitVideoControl(engine);
+    if (!adminToolkitVideoControl ||
+        !adminToolkitVideoControl.videoPlayers ||
+        adminToolkitVideoControl.videoPlayers.length === 0)
+        return [];
+    return Array.from(adminToolkitVideoControl.videoPlayers);
+}
+function checkVideoPlayerSound(entity, engine) {
+    const videoControl = getAdminToolkitVideoControl(engine);
+    const { VideoPlayer } = getExplorerComponents(engine);
+    if (videoControl?.disableVideoPlayersSound) {
+        const video = VideoPlayer.get(entity);
+        if (video.volume) {
+            VideoPlayer.getMutable(entity).volume = 0;
+        }
+    }
+}
+export function createVideoPlayerControls(entity, engine) {
+    const videoControl = getAdminToolkitVideoControl(engine);
+    const { VideoPlayer } = getExplorerComponents(engine);
+    checkVideoPlayerSound(entity, engine);
+    return {
+        play: () => {
+            VideoPlayer.getMutable(entity).playing = true;
+        },
+        pause: () => VideoPlayer.getMutable(entity).playing = false,
+        restart: () => {
+            VideoPlayer.getMutable(entity).playing = false;
+            VideoPlayer.getMutable(entity).position = 0;
+            nextTickFunctions.push(() => {
+                const video = VideoPlayer.getMutable(entity);
+                video.playing = true;
+            });
+        },
+        previous: () => {
+            console.log('TODO: Previous Track clicked');
+        },
+        next: () => {
+            console.log('TODO: Next Track clicked');
+        },
+        setVolume: (volumeOrStep) => {
+            if (videoControl?.disableVideoPlayersSound) {
+                return;
+            }
+            const video = VideoPlayer.getMutable(entity);
+            if (volumeOrStep === 0) {
+                video.volume = 0;
+            }
+            else {
+                const steps = Math.round((video.volume ?? DEFAULT_VOLUME) * 10);
+                const newSteps = Math.max(0, Math.min(10, steps + volumeOrStep * 10));
+                video.volume = newSteps / 10;
+            }
+        },
+        setSource: (url) => {
+            VideoPlayer.getMutable(entity).src = url;
+            nextTickFunctions.push(() => {
+                VideoPlayer.getMutable(entity).playing = true;
+            });
+        },
+        setLoop(loop) {
+            VideoPlayer.getMutable(entity).loop = loop;
+        }
+    };
+}
+export function useSelectedVideoPlayer(engine) {
+    const { VideoPlayer } = getExplorerComponents(engine);
+    const videoPlayers = getVideoPlayers(engine);
+    if (videoPlayers.length === 0)
+        return null;
+    const entity = videoPlayers[state.videoControl.selectedVideoPlayer ?? 0].entity;
+    const videoPlayer = VideoPlayer.getOrNull(entity);
+    return [entity, videoPlayer];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../src/admin-toolkit-ui/VideoControl/utils.tsx"],"names":[],"mappings":"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","sourcesContent":["import { DeepReadonlyObject, Entity, IEngine, PBVideoPlayer } from '@dcl/ecs'\nimport { getComponents } from '../../definitions'\nimport { getExplorerComponents } from '../../components'\nimport { nextTickFunctions, state } from '../index'\nimport { DEFAULT_VOLUME } from '.'\n\n\n// Types\ninterface VideoPlayerControls {\n  play(): void\n  pause(): void\n  restart(): void\n  previous(): void\n  next(): void\n  setVolume(volume: number): void\n  setSource(url: string): void\n  setLoop(loop: boolean): void\n}\n\nexport function getAdminToolkitVideoControl(engine: IEngine) {\n  const { AdminTools } = getComponents(engine)\n  const adminToolkitEntities = Array.from(engine.getEntitiesWith(AdminTools))\n  return adminToolkitEntities.length > 0\n    ? adminToolkitEntities[0][1].videoControl\n    : null\n}\n\nexport function getVideoPlayers(engine: IEngine) {\n  const adminToolkitVideoControl = getAdminToolkitVideoControl(engine)\n\n  if (\n    !adminToolkitVideoControl ||\n    !adminToolkitVideoControl.videoPlayers ||\n    adminToolkitVideoControl.videoPlayers.length === 0\n  )\n    return []\n\n  return Array.from(adminToolkitVideoControl.videoPlayers)\n}\n\nfunction checkVideoPlayerSound(entity: Entity, engine: IEngine) {\n  const videoControl = getAdminToolkitVideoControl(engine)\n  const { VideoPlayer } = getExplorerComponents(engine)\n\n  if (videoControl?.disableVideoPlayersSound) {\n    const video = VideoPlayer.get(entity)\n    if (video.volume) {\n      VideoPlayer.getMutable(entity).volume = 0\n    }\n  }\n}\n\nexport function createVideoPlayerControls(\n  entity: Entity,\n  engine: IEngine\n): VideoPlayerControls {\n  const videoControl = getAdminToolkitVideoControl(engine)\n  const { VideoPlayer } = getExplorerComponents(engine)\n\n  checkVideoPlayerSound(entity, engine)\n\n  return {\n    play: () => {\n      VideoPlayer.getMutable(entity).playing = true\n    },\n    pause: () => VideoPlayer.getMutable(entity).playing = false,\n    restart: () => {\n      VideoPlayer.getMutable(entity).playing = false\n      VideoPlayer.getMutable(entity).position = 0\n      nextTickFunctions.push(() => {\n        const video = VideoPlayer.getMutable(entity)\n        video.playing = true\n      })\n    },\n    previous: () => {\n      console.log('TODO: Previous Track clicked')\n    },\n    next: () => {\n      console.log('TODO: Next Track clicked')\n    },\n    setVolume: (volumeOrStep) => {\n      // Don't allow volume changes if sound is disabled\n      if (videoControl?.disableVideoPlayersSound) {\n        return\n      }\n      const video = VideoPlayer.getMutable(entity)\n      if (volumeOrStep === 0) {\n        video.volume = 0\n      } else {\n        const steps = Math.round((video.volume ?? DEFAULT_VOLUME) * 10)\n        const newSteps = Math.max(0, Math.min(10, steps + (volumeOrStep as number) * 10))\n        video.volume = newSteps / 10\n      }\n    },\n    setSource: (url) => {\n      VideoPlayer.getMutable(entity).src = url\n      nextTickFunctions.push(() => {\n        VideoPlayer.getMutable(entity).playing = true\n      })\n    },\n    setLoop(loop) {\n      VideoPlayer.getMutable(entity).loop = loop\n    }\n  }\n}\n\nexport function useSelectedVideoPlayer(\n  engine: IEngine\n): [Entity, DeepReadonlyObject<PBVideoPlayer>] | null {\n  const { VideoPlayer } = getExplorerComponents(engine)\n  const videoPlayers = getVideoPlayers(engine)\n\n  if (videoPlayers.length === 0) return null\n\n  const entity = videoPlayers[state.videoControl.selectedVideoPlayer ?? 0].entity as Entity\n  const videoPlayer = VideoPlayer.getOrNull(entity)\n  return [entity, videoPlayer!]\n}\n"]}

package/dist/admin-toolkit-ui/fetch-utils.d.ts

@@ -0,0 +1,14 @@
+import { SignedFetchRequest } from "~system/SignedFetch";
+import { PBRealmInfo } from "~system/Runtime";
+type Opts = {
+    toCamelCase?: boolean;
+};
+export declare function wrapSignedFetch<T extends any = unknown>(signedFetchBody: SignedFetchRequest, opts?: Opts): Promise<Result<T, string>>;
+export type Success<T> = [null, T];
+export type Failure<E> = [E, null];
+export type Result<T, E = Error> = Success<T> | Failure<E>;
+export declare function tryCatch<T, E = Error>(promise: Promise<T>): Promise<Result<T, E>>;
+export declare function getRealm(): Promise<PBRealmInfo | undefined>;
+export declare function isPreview(): boolean;
+export declare function getDomain(): "org" | "zone";
+export {};

package/dist/admin-toolkit-ui/fetch-utils.js

@@ -0,0 +1,41 @@
+import { signedFetch } from "~system/SignedFetch";
+import { toCamelCase } from "./utils";
+import { getRealm as getRealmRuntime } from "~system/Runtime";
+export async function wrapSignedFetch(signedFetchBody, opts = {}) {
+    const realm = await getRealm();
+    if (realm?.isPreview) {
+        return ["Try again in Genesis/World. LocalPreview not supported.", null];
+    }
+    const [error, value] = await tryCatch(signedFetch(signedFetchBody));
+    if (!value?.ok || error) {
+        console.log(`Error in ${signedFetchBody.url} endpoint`, JSON.stringify({ error, value }));
+        return [error?.message ?? value?.body ?? 'There was an error', null];
+    }
+    const [_, body] = await tryCatch(JSON.parse(value.body || '{}'));
+    return [null, opts.toCamelCase ? toCamelCase(body ?? {}) : body ?? {}];
+}
+export async function tryCatch(promise) {
+    try {
+        const data = await promise;
+        return [null, data];
+    }
+    catch (error) {
+        return [error, null];
+    }
+}
+let realmCache;
+export async function getRealm() {
+    if (realmCache)
+        return realmCache;
+    return realmCache = (await getRealmRuntime({})).realmInfo;
+}
+getRealm();
+export function isPreview() {
+    return !!realmCache?.isPreview;
+}
+export function getDomain() {
+    if (!realmCache || realmCache.networkId === 1)
+        return 'org';
+    return 'zone';
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,6 +1,17 @@
+import { Color4 } from '@dcl/sdk/math';
 import { ReactBasedUiSystem } from '@dcl/react-ecs';
 import { IEngine, PointerEventsSystem } from '@dcl/ecs';
 import { IPlayersHelper, ISDKHelpers } from '../definitions';
+import { State } from './types';
 export declare const nextTickFunctions: (() => void)[];
+export declare let scaleFactor: number;
+export declare let state: State;
+export declare const containerBackgroundColor: Color4.MutableColor4;
+export declare function fetchSceneAdmins(): Promise<void>;
+export declare function getSmartItems(engine: IEngine): import("@dcl/ecs").DeepReadonlyObject<import("@dcl/ecs").MapResult<{
+    entity: import("@dcl/ecs").ISchema<number>;
+    customName: import("@dcl/ecs").ISchema<string>;
+    defaultAction: import("@dcl/ecs").ISchema<string>;
+}>>[];
 export declare function initializeAdminData(engine: IEngine, sdkHelpers?: ISDKHelpers): Promise<void>;
 export declare function createAdminToolkitUI(engine: IEngine, pointerEventsSystem: PointerEventsSystem, reactBasedUiSystem: ReactBasedUiSystem, sdkHelpers?: ISDKHelpers, playersHelper?: IPlayersHelper): void;