dpg.broadcast-client/README.md

Library for broadcast DPG

<div align="center">
    <a href="https://digitalpartnersglobal.com"><h1>DPG | Digital Partners Global</h1></a>
</div>
Broadcast Client - 
implementation of a P2P connection between connected cameras and audio for the exchange of broadcast. 
This package use <a href="https://svelte.dev">Svelte</a> storage
<hr />

<h2>Initialization of the project</h2>
```typescript
    import instance from "dpg.broadcast-client";

    const app = instance({
        /**
         * Setting for PeerJS (PeerConnection)
         */
        peer: {
            host: "...",
            path: "...",
            secure: true,
            config: {
                iceServers: [
                    {
                        urls: ["stun:stun.l.google.com:19302"]
                    }
                ]
            }   
        },
        /**
         * Settings for socket connection
         */
        socket: {
            host: "...",
            config: {
                path: "...",
                transports: ["polling"],
                autoConnect: false // REQUIRED FALSE
            },
            cid: "..." // ID of conference for connected, if u created owner - delete key "cid"
        }
    })
```

<div>
    <hr>
</div>

<h2>Types of response and config</h2>
```typescript

    interface MediaConfig {
        audio: {
            active: boolean;
            disable: boolean;
            id: string;
        },
        camera: {
            active: boolean;
            disable: boolean;
            id: string;
        },
    }
    
    interface ConferenceConfig {
        id: string;
        started_at: number;
        users: {
            id: string;
            name: string;
            media: MediaConfig;
            pid: string;
        }[],
        owner: {
            id: string;
            name: string;
            media: MediaConfig;
        }
    }

    interface owner {
        /**
         * OnAir - it is affixed exclusively when connected to socket
         */
        onAir: boolean;
        /**
         * The value of the variable depends on the config,
         * when putting CID (ID of conference)
         */
        isOwner: boolean;
        /**
         * Status of conference
         *
         * @variation status
         * - disable - complete lack of work with the conference
         * - settings - configuring the conference configuration (owner)
         * - connections - onAir
         * - end - conference disable after connection
         */
        status: "disable" | "settings" | "connection" | "end";
        /**
         * Config of connection for working with conference
         *
         * @property connection.socket - socket instance for connection
         * @property connection.media - current media config of users
         * @property connection.peer - peer settings and config to display the current data
         */
        connection: {
            socket: Socket;
            media: MediaConfig;
            /**
             * Peer settings and config to display the current data
             *
             * @property {Peer} peer.connections - current connections for call
             * @property peer.streams - current streams to display in the interface
             */
            peer: {
                connections: {[socketID: string]: Peer};
                streams: {
                    self: MediaStream;
                    visitors: {[socketID: string]: MediaStream};
                }
            }
        };
        conference?: ConferenceConfig;

        /**
         * Media Stream type of MediaConfig
         * @param {MediaConfig} _config - config type of MediaConfig
         * @constructor
         */
        SetMediaConfig(_config: MediaConfig): void;

        /**
         * Set current user stream for call to conference
         * @param {MediaStream} _media - MediaStream for config
         * @constructor
         */
        SetStream(_media: MediaStream): void;

        /**
         * Start of Broadcast
         * @constructor
         */
        StartBroadcast(): void;

        /**
         * Initialization is store for standard projects
         * @param {String} name - name of store
         * @param val - default value of store
         * @constructor
         */
        InitStore(name: string, val: any): Writable<any>;
    }
    
    interface visitor {
        /**
         * OnAir - it is affixed exclusively when connected to socket
         */
        onAir: boolean;
        /**
         * The value of the variable depends on the config,
         * when putting CID (ID of conference)
         */
        isOwner: boolean;
        /**
         * Status of conference
         *
         * @variation status
         * - disable - complete lack of work with the conference
         * - connections - onAir
         * - end - conference disable after connection
         */
        status: "disable" | "connection" | "end";
        /**
         * Config of connection for working with conference
         *
         * @property connection.socket - socket instance for connection
         * @property connection.media - current media config of users
         * @property connection.peer - peer settings and config to display the current data
         */
        connection: {
            socket: Socket;
            media: MediaConfig;
            /**
             * Peer settings and config to display the current data
             *
             * @property {Peer} peer.connections - current connections for call
             * @property peer.streams - current streams to display in the interface
             */
            peer: {
                connections: {
                    self: {[socketID: string]: Peer};
                    visitors: {[socketID: string]: Peer};
                };
                streams: {
                    self: MediaStream;
                    visitors: {[socketID: string]: MediaStream};
                }
            }
        };
        conference?: ConferenceConfig;

        /**
         * Media Stream type of MediaConfig
         * @param {MediaConfig} _config - config type of MediaConfig
         * @constructor
         */
        SetMediaConfig(_config: MediaConfig): void;

        /**
         * Set current user stream for call to conference
         * @param {MediaStream} _media - MediaStream for config
         * @constructor
         */
        SetStream(_media: MediaStream): void;

        /**
         * Join to broadcast
         * @constructor
         */
        JoinBroadcast(): void;

        /**
         * Initialization is store for standard projects
         * @param name - name of store
         * @param val - default value of store
         * @constructor
         */
        InitStore(name: string, val: any): Writable<any>;
    }

```