@4players/odin-common/lib/esm/schema/room.js

A collection of commonly used type definitions and utility functions across ODIN web projects

import * as z from 'zod';
import { MediaIdSchema } from './media';
import { PeerIdSchema, PeerSchema } from './peer';
import { ByteArraySchema, JsonSchema } from './serialization';
import { ChannelSetSchema } from './channels';
export var RoomV1;
(function (RoomV1) {
    RoomV1.RoomIdSchema = z.string();
    RoomV1.RoomSchema = z.object({
        id: RoomV1.RoomIdSchema,
        customer: z.string(),
        user_data: ByteArraySchema,
        peers: z.array(PeerSchema),
    });
    RoomV1.RoomUpdateSchema = z.discriminatedUnion('kind', [
        z.object({
            kind: z.literal('Joined'),
            room: RoomV1.RoomSchema,
            media_ids: z.array(MediaIdSchema),
            own_peer_id: PeerIdSchema,
        }),
        z.object({
            kind: z.literal('Left'),
            reason: z.enum(['RoomClosing', 'ServerClosing', 'PeerKicked']),
        }),
        z.object({
            kind: z.literal('UserDataChanged'),
            user_data: z.optional(ByteArraySchema),
        }),
        z.object({
            kind: z.literal('PeerJoined'),
            peer: PeerSchema,
        }),
        z.object({
            kind: z.literal('PeerLeft'),
            peer_id: PeerIdSchema,
        }),
    ]);
    RoomV1.RoomUpdatesSchema = z.object({
        updates: z.array(RoomV1.RoomUpdateSchema),
    });
    RoomV1.RoomStatusSchema = z.enum(['Joining', 'Joined', 'Closed']);
    RoomV1.RoomStatusChangedSchema = z.object({
        status: RoomV1.RoomStatusSchema,
        message: z.optional(z.string()),
    });
})(RoomV1 || (RoomV1 = {}));
export var RoomV2;
(function (RoomV2) {
    RoomV2.ParametersSchema = z.record(JsonSchema);
    RoomV2.PeerProperties = z.object({
        user_data: ByteArraySchema.optional(),
        tags: z.array(z.string()).optional(),
        audio_parameters: RoomV2.ParametersSchema.optional(),
        video_parameters: RoomV2.ParametersSchema.optional(),
    });
    RoomV2.PingSchema = z.object({
        Ping: z.object({ id: z.number() }),
    });
    RoomV2.ChangeSelfSchema = z.object({
        ChangeSelf: RoomV2.PeerProperties.omit({ tags: true }),
    });
    RoomV2.SetAudioMaskSchema = z.object({
        SetAudioMask: z.object({
            peer_id: z.number(),
            mask: ChannelSetSchema,
        }),
    });
    RoomV2.SendMessageSchema = z.object({
        SendMessage: z.object({
            peer_ids: z.number().array().default([]),
            message: ByteArraySchema,
        }),
    });
    RoomV2.CallSchema = RoomV2.PingSchema.or(RoomV2.ChangeSelfSchema)
        .or(RoomV2.SetAudioMaskSchema)
        .or(RoomV2.SendMessageSchema);
    RoomV2.PongSchema = z.object({
        Pong: z.object({ id: z.number() }),
    });
    RoomV2.JoinedSchema = z.object({
        Joined: z.object({
            own_peer_id: z.number(),
            room_id: z.string(),
            customer: z.string(),
        }),
    });
    RoomV2.LeftSchema = z.object({
        Left: z.object({
            reason: z.enum(['room_closing', 'server_closing', 'peer_kicked']),
        }),
    });
    RoomV2.PeerJoinedSchema = z.object({
        PeerJoined: RoomV2.PeerProperties.extend({
            peer_id: z.number(),
            user_id: z.string(),
        }),
    });
    RoomV2.PeerLeftSchema = z.object({
        PeerLeft: z.object({
            peer_id: z.number(),
        }),
    });
    RoomV2.PeerChangedSchema = z.object({
        PeerChanged: RoomV2.PeerProperties.extend({
            peer_id: z.number(),
        }),
    });
    RoomV2.NewReconnectTokenSchema = z.object({
        NewReconnectToken: z.object({
            token: z.string(),
        }),
    });
    RoomV2.MessageReceivedSchema = z.object({
        MessageReceived: z.object({
            sender_peer_id: z.number(),
            message: ByteArraySchema,
        }),
    });
    RoomV2.ErrorSchema = z.object({
        Error: z.object({
            message: ByteArraySchema,
        }),
    });
    RoomV2.EventSchema = RoomV2.PongSchema.or(RoomV2.JoinedSchema)
        .or(RoomV2.LeftSchema)
        .or(RoomV2.PeerJoinedSchema)
        .or(RoomV2.PeerLeftSchema)
        .or(RoomV2.PeerChangedSchema)
        .or(RoomV2.NewReconnectTokenSchema)
        .or(RoomV2.MessageReceivedSchema)
        .or(RoomV2.ErrorSchema);
})(RoomV2 || (RoomV2 = {}));