@workadventure/iframe-api-typings 1.25.14 → 1.26.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workadventure/iframe-api-typings",
-  "version": "v1.25.14",
+  "version": "v1.26.0",
   "description": "Typescript typings for WorkAdventure iFrame API",
   "main": "iframe_api.js",
   "types": "iframe_api.d.ts",

package/play/src/front/Api/Events/IframeEvent.d.ts

@@ -1227,15 +1227,15 @@ export declare const isIframeEventWrapper: z.ZodUnion<[z.ZodObject<{
         bgColor: z.ZodOptional<z.ZodString>;
         textColor: z.ZodOptional<z.ZodString>;
         imageSrc: z.ZodOptional<z.ZodString>;
-        isGradient: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        isGradient: z.ZodOptional<z.ZodBoolean>;
     }, "strip", z.ZodTypeAny, {
         id: string;
-        isGradient: boolean;
         label?: string | undefined;
         toolTip?: string | undefined;
         bgColor?: string | undefined;
         textColor?: string | undefined;
         imageSrc?: string | undefined;
+        isGradient?: boolean | undefined;
     }, {
         id: string;
         label?: string | undefined;
@@ -1249,12 +1249,12 @@ export declare const isIframeEventWrapper: z.ZodUnion<[z.ZodObject<{
     type: "addButtonActionBar";
     data: {
         id: string;
-        isGradient: boolean;
         label?: string | undefined;
         toolTip?: string | undefined;
         bgColor?: string | undefined;
         textColor?: string | undefined;
         imageSrc?: string | undefined;
+        isGradient?: boolean | undefined;
     };
 }, {
     type: "addButtonActionBar";
@@ -4306,7 +4306,7 @@ export declare const iframeQueryMapTypeGuards: {
     };
 };
 type IframeQueryMapTypeGuardsType = typeof iframeQueryMapTypeGuards;
-type UnknownToVoid<T> = undefined extends T ? void : T;
+export type UnknownToVoid<T> = undefined extends T ? void : T;
 export type IframeQueryMap = {
     [key in keyof IframeQueryMapTypeGuardsType]: {
         query: z.infer<(typeof iframeQueryMapTypeGuards)[key]["query"]>;
@@ -4344,7 +4344,7 @@ export declare const isIframeErrorAnswerEvent: z.ZodObject<{
     id: number;
 }>;
 /**
- * A message sent from the game to the iFrame when a user enters or leaves a zone.
+ * A message sent from the game to the iFrame when an error occurs while processing a query.
  */
 export type IframeErrorAnswerEvent = z.infer<typeof isIframeErrorAnswerEvent>;
 export {};

package/play/src/front/Api/Events/MessagePortEvents.d.ts

@@ -0,0 +1,352 @@
+import { z } from "zod";
+/**
+ * List of events that can open a message channel/port between the game and the iFrame.
+ * For each message port, we define a type (key), zod validator for data passed on creation, and the
+ * list of events that can be sent and received through this message port.
+ */
+export declare const iframeMessagePortTypeGuards: {
+    joinSpace: {
+        data: z.ZodObject<{
+            spaceName: z.ZodString;
+            filterType: z.ZodEnum<["everyone", "streaming"]>;
+        }, "strip", z.ZodTypeAny, {
+            spaceName: string;
+            filterType: "everyone" | "streaming";
+        }, {
+            spaceName: string;
+            filterType: "everyone" | "streaming";
+        }>;
+        iframeEvents: z.ZodUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"watch">;
+            data: z.ZodUndefined;
+        }, "strip", z.ZodTypeAny, {
+            type: "watch";
+            data?: undefined;
+        }, {
+            type: "watch";
+            data?: undefined;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"unwatch">;
+            data: z.ZodUndefined;
+        }, "strip", z.ZodTypeAny, {
+            type: "unwatch";
+            data?: undefined;
+        }, {
+            type: "unwatch";
+            data?: undefined;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"leave">;
+            data: z.ZodUndefined;
+        }, "strip", z.ZodTypeAny, {
+            type: "leave";
+            data?: undefined;
+        }, {
+            type: "leave";
+            data?: undefined;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"startStreaming">;
+            data: z.ZodUndefined;
+        }, "strip", z.ZodTypeAny, {
+            type: "startStreaming";
+            data?: undefined;
+        }, {
+            type: "startStreaming";
+            data?: undefined;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"stopStreaming">;
+            data: z.ZodUndefined;
+        }, "strip", z.ZodTypeAny, {
+            type: "stopStreaming";
+            data?: undefined;
+        }, {
+            type: "stopStreaming";
+            data?: undefined;
+        }>]>;
+        workAdventureEvents: z.ZodUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"onNewUser">;
+            data: z.ZodObject<{
+                spaceUserId: z.ZodString;
+                name: z.ZodString;
+                playUri: z.ZodString;
+                isLogged: z.ZodBoolean;
+                availabilityStatus: z.ZodNumber;
+                tags: z.ZodArray<z.ZodString, "many">;
+                cameraState: z.ZodBoolean;
+                microphoneState: z.ZodBoolean;
+                screenSharingState: z.ZodBoolean;
+                megaphoneState: z.ZodBoolean;
+                uuid: z.ZodString;
+                chatID: z.ZodOptional<z.ZodString>;
+                showVoiceIndicator: z.ZodBoolean;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+                uuid: string;
+                tags: string[];
+                isLogged: boolean;
+                playUri: string;
+                availabilityStatus: number;
+                spaceUserId: string;
+                cameraState: boolean;
+                microphoneState: boolean;
+                screenSharingState: boolean;
+                megaphoneState: boolean;
+                showVoiceIndicator: boolean;
+                chatID?: string | undefined;
+            }, {
+                name: string;
+                uuid: string;
+                tags: string[];
+                isLogged: boolean;
+                playUri: string;
+                availabilityStatus: number;
+                spaceUserId: string;
+                cameraState: boolean;
+                microphoneState: boolean;
+                screenSharingState: boolean;
+                megaphoneState: boolean;
+                showVoiceIndicator: boolean;
+                chatID?: string | undefined;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            type: "onNewUser";
+            data: {
+                name: string;
+                uuid: string;
+                tags: string[];
+                isLogged: boolean;
+                playUri: string;
+                availabilityStatus: number;
+                spaceUserId: string;
+                cameraState: boolean;
+                microphoneState: boolean;
+                screenSharingState: boolean;
+                megaphoneState: boolean;
+                showVoiceIndicator: boolean;
+                chatID?: string | undefined;
+            };
+        }, {
+            type: "onNewUser";
+            data: {
+                name: string;
+                uuid: string;
+                tags: string[];
+                isLogged: boolean;
+                playUri: string;
+                availabilityStatus: number;
+                spaceUserId: string;
+                cameraState: boolean;
+                microphoneState: boolean;
+                screenSharingState: boolean;
+                megaphoneState: boolean;
+                showVoiceIndicator: boolean;
+                chatID?: string | undefined;
+            };
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"onDeleteUser">;
+            data: z.ZodObject<{
+                spaceUserId: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                spaceUserId: string;
+            }, {
+                spaceUserId: string;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            type: "onDeleteUser";
+            data: {
+                spaceUserId: string;
+            };
+        }, {
+            type: "onDeleteUser";
+            data: {
+                spaceUserId: string;
+            };
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"onUpdateUser">;
+            data: z.ZodObject<{
+                spaceUserId: z.ZodString;
+                changes: z.ZodObject<{
+                    spaceUserId: z.ZodOptional<z.ZodString>;
+                    name: z.ZodOptional<z.ZodString>;
+                    playUri: z.ZodOptional<z.ZodString>;
+                    isLogged: z.ZodOptional<z.ZodBoolean>;
+                    availabilityStatus: z.ZodOptional<z.ZodNumber>;
+                    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                    cameraState: z.ZodOptional<z.ZodBoolean>;
+                    microphoneState: z.ZodOptional<z.ZodBoolean>;
+                    screenSharingState: z.ZodOptional<z.ZodBoolean>;
+                    megaphoneState: z.ZodOptional<z.ZodBoolean>;
+                    uuid: z.ZodOptional<z.ZodString>;
+                    chatID: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+                    showVoiceIndicator: z.ZodOptional<z.ZodBoolean>;
+                }, "strip", z.ZodTypeAny, {
+                    name?: string | undefined;
+                    uuid?: string | undefined;
+                    tags?: string[] | undefined;
+                    isLogged?: boolean | undefined;
+                    playUri?: string | undefined;
+                    availabilityStatus?: number | undefined;
+                    chatID?: string | undefined;
+                    spaceUserId?: string | undefined;
+                    cameraState?: boolean | undefined;
+                    microphoneState?: boolean | undefined;
+                    screenSharingState?: boolean | undefined;
+                    megaphoneState?: boolean | undefined;
+                    showVoiceIndicator?: boolean | undefined;
+                }, {
+                    name?: string | undefined;
+                    uuid?: string | undefined;
+                    tags?: string[] | undefined;
+                    isLogged?: boolean | undefined;
+                    playUri?: string | undefined;
+                    availabilityStatus?: number | undefined;
+                    chatID?: string | undefined;
+                    spaceUserId?: string | undefined;
+                    cameraState?: boolean | undefined;
+                    microphoneState?: boolean | undefined;
+                    screenSharingState?: boolean | undefined;
+                    megaphoneState?: boolean | undefined;
+                    showVoiceIndicator?: boolean | undefined;
+                }>;
+                updateMask: z.ZodArray<z.ZodString, "many">;
+            }, "strip", z.ZodTypeAny, {
+                spaceUserId: string;
+                changes: {
+                    name?: string | undefined;
+                    uuid?: string | undefined;
+                    tags?: string[] | undefined;
+                    isLogged?: boolean | undefined;
+                    playUri?: string | undefined;
+                    availabilityStatus?: number | undefined;
+                    chatID?: string | undefined;
+                    spaceUserId?: string | undefined;
+                    cameraState?: boolean | undefined;
+                    microphoneState?: boolean | undefined;
+                    screenSharingState?: boolean | undefined;
+                    megaphoneState?: boolean | undefined;
+                    showVoiceIndicator?: boolean | undefined;
+                };
+                updateMask: string[];
+            }, {
+                spaceUserId: string;
+                changes: {
+                    name?: string | undefined;
+                    uuid?: string | undefined;
+                    tags?: string[] | undefined;
+                    isLogged?: boolean | undefined;
+                    playUri?: string | undefined;
+                    availabilityStatus?: number | undefined;
+                    chatID?: string | undefined;
+                    spaceUserId?: string | undefined;
+                    cameraState?: boolean | undefined;
+                    microphoneState?: boolean | undefined;
+                    screenSharingState?: boolean | undefined;
+                    megaphoneState?: boolean | undefined;
+                    showVoiceIndicator?: boolean | undefined;
+                };
+                updateMask: string[];
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            type: "onUpdateUser";
+            data: {
+                spaceUserId: string;
+                changes: {
+                    name?: string | undefined;
+                    uuid?: string | undefined;
+                    tags?: string[] | undefined;
+                    isLogged?: boolean | undefined;
+                    playUri?: string | undefined;
+                    availabilityStatus?: number | undefined;
+                    chatID?: string | undefined;
+                    spaceUserId?: string | undefined;
+                    cameraState?: boolean | undefined;
+                    microphoneState?: boolean | undefined;
+                    screenSharingState?: boolean | undefined;
+                    megaphoneState?: boolean | undefined;
+                    showVoiceIndicator?: boolean | undefined;
+                };
+                updateMask: string[];
+            };
+        }, {
+            type: "onUpdateUser";
+            data: {
+                spaceUserId: string;
+                changes: {
+                    name?: string | undefined;
+                    uuid?: string | undefined;
+                    tags?: string[] | undefined;
+                    isLogged?: boolean | undefined;
+                    playUri?: string | undefined;
+                    availabilityStatus?: number | undefined;
+                    chatID?: string | undefined;
+                    spaceUserId?: string | undefined;
+                    cameraState?: boolean | undefined;
+                    microphoneState?: boolean | undefined;
+                    screenSharingState?: boolean | undefined;
+                    megaphoneState?: boolean | undefined;
+                    showVoiceIndicator?: boolean | undefined;
+                };
+                updateMask: string[];
+            };
+        }>]>;
+    };
+};
+type IframeMessagePortTypeGuards = typeof iframeMessagePortTypeGuards;
+export type IframeMessagePortMap = {
+    [key in keyof IframeMessagePortTypeGuards]: {
+        data: z.infer<IframeMessagePortTypeGuards[key]["data"]>;
+        iframeEvents: z.infer<IframeMessagePortTypeGuards[key]["iframeEvents"]>;
+        workAdventureEvents: IframeMessagePortTypeGuards[key]["workAdventureEvents"];
+    };
+};
+export interface IframeMessagePortData<T extends keyof IframeMessagePortMap> {
+    type: T;
+    data: IframeMessagePortMap[T]["data"];
+}
+export interface MessagePortIframeEvent<T extends keyof IframeMessagePortMap> {
+    type: T;
+    data: IframeMessagePortMap[T]["iframeEvents"];
+}
+export interface MessagePortWorkAdventureEvent<T extends keyof IframeMessagePortMap> {
+    type: T;
+    data: IframeMessagePortMap[T]["workAdventureEvents"];
+}
+export declare const isIframeMessagePortType: (type: string) => type is keyof IframeMessagePortMap;
+export interface IframeMessagePortWrapper<T extends keyof IframeMessagePortMap> {
+    messagePort: true;
+    id: number;
+    type: T;
+    data: IframeMessagePortMap[T]["data"];
+}
+export declare const isIframeMessagePortWrapper: (event: any) => event is IframeMessagePortWrapper<keyof IframeMessagePortMap>;
+export declare const isIframeErrorMessagePortEvent: z.ZodObject<{
+    id: z.ZodNumber;
+    error: z.ZodString;
+    messagePort: z.ZodLiteral<true>;
+}, "strip", z.ZodTypeAny, {
+    error: string;
+    id: number;
+    messagePort: true;
+}, {
+    error: string;
+    id: number;
+    messagePort: true;
+}>;
+/**
+ * A message sent from the game to the iFrame when an error occurs while processing a message port opening.
+ */
+export type IframeErrorMessagePortEvent = z.infer<typeof isIframeErrorMessagePortEvent>;
+export declare const isIframeSuccessMessagePortEvent: z.ZodObject<{
+    id: z.ZodNumber;
+    messagePort: z.ZodLiteral<true>;
+}, "strip", z.ZodTypeAny, {
+    id: number;
+    messagePort: true;
+}, {
+    id: number;
+    messagePort: true;
+}>;
+/**
+ * A message sent from the game to the iFrame when an error occurs while processing a message port opening.
+ */
+export type IframeSuccessMessagePortEvent = z.infer<typeof isIframeSuccessMessagePortEvent>;
+export {};

package/play/src/front/Api/Events/NewSpaceUserEvent.d.ts

@@ -0,0 +1,45 @@
+import { z } from "zod";
+export declare const NewSpaceUserEvent: z.ZodObject<{
+    spaceUserId: z.ZodString;
+    name: z.ZodString;
+    playUri: z.ZodString;
+    isLogged: z.ZodBoolean;
+    availabilityStatus: z.ZodNumber;
+    tags: z.ZodArray<z.ZodString, "many">;
+    cameraState: z.ZodBoolean;
+    microphoneState: z.ZodBoolean;
+    screenSharingState: z.ZodBoolean;
+    megaphoneState: z.ZodBoolean;
+    uuid: z.ZodString;
+    chatID: z.ZodOptional<z.ZodString>;
+    showVoiceIndicator: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    uuid: string;
+    tags: string[];
+    isLogged: boolean;
+    playUri: string;
+    availabilityStatus: number;
+    spaceUserId: string;
+    cameraState: boolean;
+    microphoneState: boolean;
+    screenSharingState: boolean;
+    megaphoneState: boolean;
+    showVoiceIndicator: boolean;
+    chatID?: string | undefined;
+}, {
+    name: string;
+    uuid: string;
+    tags: string[];
+    isLogged: boolean;
+    playUri: string;
+    availabilityStatus: number;
+    spaceUserId: string;
+    cameraState: boolean;
+    microphoneState: boolean;
+    screenSharingState: boolean;
+    megaphoneState: boolean;
+    showVoiceIndicator: boolean;
+    chatID?: string | undefined;
+}>;
+export type NewSpaceUserEvent = z.infer<typeof NewSpaceUserEvent>;

package/play/src/front/Api/Events/Ui/ButtonActionBarEvent.d.ts

@@ -6,15 +6,15 @@ export declare const isAddActionBarButtonEvent: z.ZodObject<{
     bgColor: z.ZodOptional<z.ZodString>;
     textColor: z.ZodOptional<z.ZodString>;
     imageSrc: z.ZodOptional<z.ZodString>;
-    isGradient: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    isGradient: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     id: string;
-    isGradient: boolean;
     label?: string | undefined;
     toolTip?: string | undefined;
     bgColor?: string | undefined;
     textColor?: string | undefined;
     imageSrc?: string | undefined;
+    isGradient?: boolean | undefined;
 }, {
     id: string;
     label?: string | undefined;

package/play/src/front/Api/Iframe/CheckedIframeMessagePort.d.ts

@@ -0,0 +1,18 @@
+import { z } from "zod";
+import { Observable } from "rxjs";
+import { IframeMessagePortMap, MessagePortIframeEvent, MessagePortWorkAdventureEvent } from "../Events/MessagePortEvents";
+type MessagePortMessageEvent<K extends keyof IframeMessagePortMap> = MessageEvent<z.infer<MessagePortWorkAdventureEvent<K>["data"]>>;
+/**
+ * A wrapper around a MessagePort that ensures the messages sent and received conform to a specific type.
+ * This class is used on the iframe side to communicate with the main application.
+ */
+export declare class CheckedIframeMessagePort<K extends keyof IframeMessagePortMap> {
+    private type;
+    private readonly port;
+    private readonly _messages;
+    readonly messages: Observable<MessagePortMessageEvent<K>>;
+    constructor(port: MessagePort, type: K);
+    postMessage(message: MessagePortIframeEvent<K>["data"]): void;
+    close(): void;
+}
+export {};

package/play/src/front/Api/Iframe/IframeApiContribution.d.ts

@@ -1,10 +1,17 @@
-import type { IframeEvent, IframeQuery, IframeQueryMap } from "../Events/IframeEvent";
+import { IframeEvent, IframeQuery, IframeQueryMap } from "../Events/IframeEvent";
+import { IframeMessagePortData, IframeMessagePortMap } from "../Events/MessagePortEvents";
+import { CheckedIframeMessagePort } from "./CheckedIframeMessagePort";
 export declare function sendToWorkadventure(content: IframeEvent, transfer?: Transferable[]): void;
 export declare const answerPromises: Map<number, {
     resolve: (value: IframeQueryMap[keyof IframeQueryMap]["answer"] | PromiseLike<IframeQueryMap[keyof IframeQueryMap]["answer"]>) => void;
     reject: (reason?: any) => void;
 }>;
+export declare const answerPromisesMessagePort: Map<number, {
+    resolve: () => void;
+    reject: (reason?: any) => void;
+}>;
 export declare function queryWorkadventure<T extends keyof IframeQueryMap>(content: IframeQuery<T>, transfer?: Transferable[]): Promise<IframeQueryMap[T]["answer"]>;
+export declare function openMessagePort<K extends keyof IframeMessagePortMap>(type: K, data: IframeMessagePortData<K>["data"]): Promise<CheckedIframeMessagePort<K>>;
 /**
  * !! be aware that the implemented attributes (addMethodsAtRoot and subObjectIdentifier) must be readonly
  *

package/play/src/front/Api/Iframe/Spaces/Space.d.ts

@@ -0,0 +1,21 @@
+import { Observable } from "rxjs";
+import { CheckedIframeMessagePort } from "../CheckedIframeMessagePort";
+import { SpaceUser } from "./SpaceUser";
+export declare class Space {
+    private readonly port;
+    private watchCount;
+    private messagesSubscription;
+    private readonly users;
+    readonly userJoinedObservable: Observable<SpaceUser>;
+    readonly userLeftObservable: Observable<SpaceUser>;
+    private _userJoinedSubscriber;
+    private _userLeftSubscriber;
+    private left;
+    constructor(port: CheckedIframeMessagePort<"joinSpace">);
+    private createReactiveUser;
+    private watch;
+    private unwatch;
+    leave(): void;
+    startStreaming(): void;
+    stopStreaming(): void;
+}

package/play/src/front/Api/Iframe/Spaces/SpaceUser.d.ts

@@ -0,0 +1,8 @@
+import { Observable } from "rxjs";
+import { NewSpaceUserEvent } from "../../Events/NewSpaceUserEvent";
+export type SpaceUser = NewSpaceUserEvent & {
+    reactiveUser: ReactiveSpaceUser;
+};
+export type ReactiveSpaceUser = {
+    [K in keyof Omit<SpaceUser, "spaceUserId">]: Readonly<Observable<SpaceUser[K]>>;
+};

package/play/src/front/Api/Iframe/spaces.d.ts

@@ -0,0 +1,22 @@
+import { IframeApiContribution } from "./IframeApiContribution";
+import { Space } from "./Spaces/Space";
+export declare class WorkAdventureSpacesCommands extends IframeApiContribution<WorkAdventureSpacesCommands> {
+    callbacks: never[];
+    /**
+     * Joins a space.
+     * A space is a structure containing a set of players.
+     * Players in a space can talk to each others.
+     *
+     * Use this if you want some players to be able to talk to each others without going through a bubble or a meeting room.
+     * Note: users in the same world, but on different maps, can be part of the same space.
+     * The spaceName is scope to the world.
+     *
+     * {@link https://docs.workadventu.re/map-building/api-spaces.md#start-following-player | Website documentation}
+     *
+     * @param {string} spaceName Name of the space to join
+     * @param {("everyone"|"streaming")} filterType Type of filter to apply when joining the space. THis must match the filter decided by the first person joining the space.
+     */
+    joinSpace(spaceName: string, filterType: "everyone" | "streaming"): Promise<Space>;
+}
+declare const _default: WorkAdventureSpacesCommands;
+export default _default;

package/play/src/iframe_api.d.ts

@@ -29,6 +29,7 @@ declare const wa: {
     player: import("./front/Api/Iframe/player").WorkadventurePlayerCommands;
     players: import("./front/Api/Iframe/players").WorkadventurePlayersCommands;
     camera: import("./front/Api/Iframe/camera").WorkAdventureCameraCommands;
+    spaces: import("./front/Api/Iframe/spaces").WorkAdventureSpacesCommands;
     state: import("./front/Api/Iframe/state").WorkadventureStateCommands & import("./front/Api/Iframe/RoomState").RoomState;
     event: import("./front/Api/Iframe/event").WorkadventureEventCommands;
     mapEditor: import("./front/Api/Iframe/mapEditor").WorkadventureMapEditorCommands;