@digitalsamba/embedded-sdk 0.0.12 → 0.0.17

package/dist/cjs/types.d.ts

@@ -1,11 +1,28 @@
-export interface InitOptions {
+import { PermissionsMap } from './utils/PermissionManager/types';
+import { LayoutMode, PermissionTypes } from './utils/vars';
+export interface InitialRoomSettings {
+    cameraEnabled: boolean;
+    micEnabled: boolean;
+    username: string;
+    layoutMode: LayoutMode;
+    showToolbar: boolean;
+    showCaptions: boolean;
+    virtualBackground: {
+        blur: 'medium' | 'strong';
+        image: 'office' | 'etc' | /* OR */ 'custom-xxxxxx';
+        imageUrl: 'https://image.url';
+        enforce: true;
+    };
+}
+export type InitOptions = {
     root: HTMLElement;
     frame: HTMLIFrameElement;
     url: string;
     team: string;
     room: string;
     token?: string;
-}
+    roomSettings: Partial<InitialRoomSettings>;
+};
 export type FrameAttributes = {
     align: string;
     allow: string;
@@ -26,8 +43,8 @@ export interface InstanceProperties {
     frameAttributes?: Partial<FrameAttributes>;
     reportErrors?: boolean;
 }
-export type SendMessageType = 'connect' | 'enableVideo' | 'enableAudio' | 'disableVideo' | 'disableAudio' | 'toggleVideo' | 'toggleAudio' | 'startScreenshare' | 'stopScreenshare' | 'startRecording' | 'stopRecording' | 'showToolbar' | 'hideToolbar' | 'toggleToolbar' | 'changeLayoutMode' | 'leaveSession' | 'endSession' | 'requestToggleAudio' | 'requestMute' | 'requestUnmute';
-export type ReceiveMessageType = 'connected' | 'userJoined' | 'userLeft' | 'videoEnabled' | 'videoDisabled' | 'audioEnabled' | 'audioDisabled' | 'screenshareStarted' | 'screenshareStopped' | 'recordingStarted' | 'recordingStopped' | 'recordingFailed' | 'layoutModeChanged' | 'activeSpeakerChanged' | 'appError';
+export type SendMessageType = 'connect' | 'enableVideo' | 'enableAudio' | 'disableVideo' | 'disableAudio' | 'toggleVideo' | 'toggleAudio' | 'startScreenshare' | 'stopScreenshare' | 'startRecording' | 'stopRecording' | 'showToolbar' | 'hideToolbar' | 'toggleToolbar' | 'changeLayoutMode' | 'leaveSession' | 'endSession' | 'requestToggleAudio' | 'requestMute' | 'requestUnmute' | 'removeUser' | 'showCaptions' | 'hideCaptions' | 'toggleCaptions' | 'configureCaptions' | 'raiseHand' | 'lowerHand' | 'allowBroadcast' | 'disallowBroadcast' | 'allowScreenshare' | 'disallowScreenshare';
+export type ReceiveMessageType = 'connected' | 'userJoined' | 'userLeft' | 'roomJoined' | 'videoEnabled' | 'videoDisabled' | 'audioEnabled' | 'audioDisabled' | 'screenshareStarted' | 'screenshareStopped' | 'recordingStarted' | 'recordingStopped' | 'recordingFailed' | 'layoutModeChanged' | 'activeSpeakerChanged' | 'appError' | 'captionsSpokenLanguageChanged' | 'captionsFontSizeChanged' | 'permissionsChanged' | 'handRaised' | 'handLowered';
 export interface SendMessage<D> {
     type: SendMessageType;
     data?: D;
@@ -35,11 +52,89 @@ export interface SendMessage<D> {
 export interface ReceiveMessage {
     DSPayload: {
         type: ReceiveMessageType;
-        payload: unknown;
+        data: unknown;
     };
 }
-export declare enum LayoutMode {
-    tiled = "tiled",
-    auto = "auto"
-}
 export type UserId = string;
+export interface User {
+    avatarColor: string;
+    id: UserId;
+    name: string;
+    role: string;
+    kind: 'local' | 'remote';
+    dynamicPermissions: PermissionTypes[] | undefined;
+}
+export type CaptionsSpokenLanguage = 'zh' | 'zh-CN' | 'zh-TW' | 'da' | 'nl' | 'en' | 'en-AU' | 'en-GB' | 'en-IN' | 'en-NZ' | 'en-US' | 'fr' | 'fr-CA' | 'de' | 'hi' | 'hi-Latn' | 'id' | 'it' | 'ja' | 'ko' | 'no' | 'pl' | 'pt' | 'pt-BR' | 'pt-PT' | 'ru' | 'es' | 'es-419' | 'sv' | 'ta' | 'tr' | 'uk';
+type CaptionsFontSize = 'small' | 'medium' | 'large';
+export interface CaptionsOptions {
+    spokenLanguage: CaptionsSpokenLanguage;
+    fontSize: CaptionsFontSize;
+}
+export type UsersList = Record<UserId, User>;
+export interface RoomState {
+    media: {
+        cameraEnabled: boolean;
+        micEnabled: boolean;
+    };
+    layout: {
+        mode: LayoutMode;
+        showToolbar: boolean;
+        toolbarPosition: 'left' | 'right' | 'bottom';
+    };
+    captionsState: {
+        showCaptions: boolean;
+    } & CaptionsOptions;
+}
+export interface Stored {
+    userId: UserId;
+    users: UsersList;
+    activeSpeaker?: UserId;
+    roomState: RoomState;
+}
+export type RoomJoinedPayload = Stored & {
+    permissionsMap: PermissionsMap;
+};
+export interface EmbeddedInstance {
+    initOptions: Partial<InitOptions>;
+    roomSettings: Partial<InitialRoomSettings>;
+    savedIframeSrc: string;
+    allowedOrigin: string;
+    connected: boolean;
+    frame: HTMLIFrameElement;
+    reportErrors: boolean;
+    stored: Stored;
+    enableVideo: () => void;
+    disableVideo: () => void;
+    toggleVideo: (enable?: boolean) => void;
+    enableAudio: () => void;
+    disableAudio: () => void;
+    toggleAudio: (enable?: boolean) => void;
+    startScreenshare: () => void;
+    stopScreenshare: () => void;
+    startRecording: () => void;
+    stopRecording: () => void;
+    showToolbar: () => void;
+    hideToolbar: () => void;
+    changeLayoutMode: (mode: LayoutMode) => void;
+    leaveSession: () => void;
+    endSession: () => void;
+    toggleToolbar: (show?: boolean) => void;
+    requestToggleAudio: (userId: UserId, shouldMute?: boolean) => void;
+    requestMute: (userId: UserId) => void;
+    requestUnmute: (userId: UserId) => void;
+    removeUser: (userId: UserId) => void;
+    listUsers: () => User[];
+    get roomState(): RoomState;
+    get localUser(): User;
+    showCaptions: () => void;
+    hideCaptions: () => void;
+    toggleCaptions: (show?: boolean) => void;
+    configureCaptions: (options: Partial<CaptionsOptions>) => void;
+    raiseHand: () => void;
+    lowerHand: (target?: UserId) => void;
+    allowBroadcast: (userId: UserId) => void;
+    disallowBroadcast: (userId: UserId) => void;
+    allowScreenshare: (userId: UserId) => void;
+    disallowScreenshare: (userId: UserId) => void;
+}
+export {};

package/dist/cjs/types.js

@@ -1,8 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LayoutMode = void 0;
-var LayoutMode;
-(function (LayoutMode) {
-    LayoutMode["tiled"] = "tiled";
-    LayoutMode["auto"] = "auto";
-})(LayoutMode = exports.LayoutMode || (exports.LayoutMode = {}));

package/dist/cjs/utils/PermissionManager/index.d.ts

@@ -0,0 +1,13 @@
+import { CheckPermissionsOptions, HasPermissionsOptions, LookupPermissionOptions, PermissionsMap, RefinePermissionsOptions } from './types';
+import { PermissionTypes } from '../vars';
+import { EmbeddedInstance } from '../../types';
+export declare class PermissionManager {
+    parent: EmbeddedInstance;
+    permissionsMap: PermissionsMap;
+    constructor(parent: EmbeddedInstance);
+    lookupDynamicPermission: (permission: PermissionTypes, dynamicPermissions: PermissionTypes[] | undefined) => boolean;
+    lookupPermission: (options: LookupPermissionOptions) => boolean;
+    checkPermissions: ({ permissions, targetRole, permissionsMap, role, dynamicPermissions, }: CheckPermissionsOptions) => boolean;
+    refinePermissions: (permissions: PermissionTypes | PermissionTypes[], { targetRole, role, userId, users, permissionsMap, localUser }: RefinePermissionsOptions) => boolean;
+    hasPermissions: (permissions: PermissionTypes | PermissionTypes[], { targetRole, role, userId }?: HasPermissionsOptions) => boolean;
+}

package/dist/cjs/utils/PermissionManager/index.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PermissionManager = void 0;
+class PermissionManager {
+    constructor(parent) {
+        this.permissionsMap = {};
+        this.lookupDynamicPermission = (permission, dynamicPermissions) => {
+            if (!dynamicPermissions) {
+                return false;
+            }
+            return dynamicPermissions.includes(permission);
+        };
+        this.lookupPermission = (options) => {
+            const { permissionsMap, permission, targetRole, role, dynamicPermissions } = options;
+            if (dynamicPermissions) {
+                const granted = this.lookupDynamicPermission(permission, dynamicPermissions);
+                if (granted) {
+                    return true;
+                }
+            }
+            if (permissionsMap[role][permission]) {
+                return true;
+            }
+            return Boolean(permissionsMap[role][`${permission}_${targetRole}`]);
+        };
+        this.checkPermissions = ({ permissions, targetRole, permissionsMap, role, dynamicPermissions, }) => {
+            if (Array.isArray(permissions)) {
+                return permissions.some((permission) => this.lookupPermission({ permission, targetRole, role, permissionsMap, dynamicPermissions }));
+            }
+            return this.lookupPermission({
+                permission: permissions,
+                targetRole,
+                role,
+                permissionsMap,
+                dynamicPermissions,
+            });
+        };
+        this.refinePermissions = (permissions, { targetRole, role, userId, users, permissionsMap, localUser }) => {
+            const options = {
+                permissionsMap,
+                permissions,
+                targetRole,
+                role: localUser.role,
+                dynamicPermissions: localUser.dynamicPermissions,
+            };
+            if (role) {
+                options.role = role;
+                options.dynamicPermissions = undefined;
+            }
+            if (userId && users) {
+                options.role = users[userId].role;
+                options.dynamicPermissions = users[userId].dynamicPermissions;
+            }
+            return this.checkPermissions(options);
+        };
+        this.hasPermissions = (permissions, { targetRole, role, userId } = {}) => {
+            const users = this.parent.stored.users;
+            const localUser = this.parent.localUser;
+            if (!localUser) {
+                return false;
+            }
+            return this.refinePermissions(permissions, {
+                permissionsMap: this.permissionsMap,
+                role,
+                targetRole,
+                users,
+                userId,
+                localUser,
+            });
+        };
+        this.parent = parent;
+    }
+}
+exports.PermissionManager = PermissionManager;

package/dist/cjs/utils/PermissionManager/types.d.ts

@@ -0,0 +1,23 @@
+import { User, UserId } from '../../types';
+import { PermissionTypes } from '../vars';
+export type PermissionsMap = Record<string, Record<string, boolean>>;
+export interface HasPermissionsOptions {
+    targetRole?: string;
+    role?: string;
+    userId?: UserId;
+}
+export interface RefinePermissionsOptions extends HasPermissionsOptions {
+    permissionsMap: PermissionsMap;
+    localUser: User;
+    users?: Record<UserId, User>;
+}
+export interface LookupPermissionOptions {
+    permissionsMap: PermissionsMap;
+    permission: PermissionTypes;
+    role: string;
+    targetRole?: string;
+    dynamicPermissions?: PermissionTypes[];
+}
+export interface CheckPermissionsOptions extends Omit<LookupPermissionOptions, 'permission'> {
+    permissions: PermissionTypes | PermissionTypes[];
+}

package/dist/cjs/utils/PermissionManager/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/utils/proxy.d.ts

@@ -0,0 +1 @@
+export declare const createWatchedProxy: <G>(initialState: G, onChange: (newState: G) => void) => any;

package/dist/cjs/utils/proxy.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWatchedProxy = void 0;
+const createHandler = (onChange) => {
+    const handler = {
+        get(target, key) {
+            if (typeof target[key] === 'object' && target[key] !== null) {
+                return new Proxy(target[key], handler);
+            }
+            return target[key];
+        },
+        set(target, prop, value) {
+            target[prop] = value;
+            onChange(target);
+            return target;
+        },
+    };
+    return handler;
+};
+const createWatchedProxy = (initialState, onChange) => new Proxy(initialState, createHandler(onChange));
+exports.createWatchedProxy = createWatchedProxy;

package/dist/cjs/utils/vars.d.ts

@@ -0,0 +1,23 @@
+import { Stored } from '../types';
+export declare const CONNECT_TIMEOUT = 10000;
+export declare const internalEvents: Record<string, boolean>;
+export declare enum LayoutMode {
+    tiled = "tiled",
+    auto = "auto"
+}
+export declare enum PermissionTypes {
+    broadcast = "broadcast",
+    manageBroadcast = "manage_broadcast",
+    endSession = "end_session",
+    startSession = "start_session",
+    removeParticipant = "remove_participant",
+    screenshare = "screenshare",
+    manageScreenshare = "manage_screenshare",
+    recording = "recording",
+    generalChat = "general_chat",
+    remoteMuting = "remote_muting",
+    askRemoteUnmute = "ask_remote_unmute",
+    raiseHand = "raise_hand",
+    manageRoles = "manage_roles"
+}
+export declare const defaultStoredState: Stored;

package/dist/cjs/utils/vars.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultStoredState = exports.PermissionTypes = exports.LayoutMode = exports.internalEvents = exports.CONNECT_TIMEOUT = void 0;
+exports.CONNECT_TIMEOUT = 10000;
+exports.internalEvents = {
+    roomJoined: true,
+};
+var LayoutMode;
+(function (LayoutMode) {
+    LayoutMode["tiled"] = "tiled";
+    LayoutMode["auto"] = "auto";
+})(LayoutMode = exports.LayoutMode || (exports.LayoutMode = {}));
+var PermissionTypes;
+(function (PermissionTypes) {
+    PermissionTypes["broadcast"] = "broadcast";
+    PermissionTypes["manageBroadcast"] = "manage_broadcast";
+    PermissionTypes["endSession"] = "end_session";
+    PermissionTypes["startSession"] = "start_session";
+    PermissionTypes["removeParticipant"] = "remove_participant";
+    PermissionTypes["screenshare"] = "screenshare";
+    PermissionTypes["manageScreenshare"] = "manage_screenshare";
+    PermissionTypes["recording"] = "recording";
+    PermissionTypes["generalChat"] = "general_chat";
+    PermissionTypes["remoteMuting"] = "remote_muting";
+    PermissionTypes["askRemoteUnmute"] = "ask_remote_unmute";
+    PermissionTypes["raiseHand"] = "raise_hand";
+    PermissionTypes["manageRoles"] = "manage_roles";
+})(PermissionTypes = exports.PermissionTypes || (exports.PermissionTypes = {}));
+exports.defaultStoredState = {
+    userId: '',
+    roomState: {
+        media: {
+            micEnabled: false,
+            cameraEnabled: false,
+        },
+        layout: {
+            mode: LayoutMode.tiled,
+            showToolbar: true,
+            toolbarPosition: 'left',
+        },
+        captionsState: {
+            showCaptions: false,
+            spokenLanguage: 'en',
+            fontSize: 'medium',
+        },
+    },
+    users: {},
+};

package/dist/esm/index.d.ts

@@ -1,23 +1,35 @@
 /// <reference types="node" />
-import { InitOptions, InstanceProperties, LayoutMode, UserId } from './types';
 import EventEmitter from 'events';
-export declare class DigitalSambaEmbedded extends EventEmitter {
+import { PermissionManager } from './utils/PermissionManager';
+import { LayoutMode } from './utils/vars';
+import { CaptionsOptions, EmbeddedInstance, InitialRoomSettings, InitOptions, InstanceProperties, Stored, UserId } from './types';
+export declare class DigitalSambaEmbedded extends EventEmitter implements EmbeddedInstance {
     initOptions: Partial<InitOptions>;
+    roomSettings: Partial<InitialRoomSettings>;
     savedIframeSrc: string;
     allowedOrigin: string;
     connected: boolean;
     frame: HTMLIFrameElement;
     reportErrors: boolean;
+    stored: Stored;
+    permissionManager: PermissionManager;
     constructor(options?: Partial<InitOptions>, instanceProperties?: Partial<InstanceProperties>, loadImmediately?: boolean);
     static createControl: (initOptions: InitOptions) => DigitalSambaEmbedded;
     private mountFrame;
     load: (instanceProperties?: InstanceProperties) => void;
     private onMessage;
+    private setupInternalEventListeners;
+    private _emit;
+    private handleInternalMessage;
+    private emitUsersUpdated;
+    private emitRoomStateUpdated;
     private setFrameSrc;
     private checkTarget;
     private sendMessage;
     private logError;
     private applyFrameProperties;
+    get roomState(): import("./types").RoomState;
+    get localUser(): import("./types").User;
     enableVideo: () => void;
     disableVideo: () => void;
     toggleVideo: (enable?: boolean) => void;
@@ -37,4 +49,16 @@ export declare class DigitalSambaEmbedded extends EventEmitter {
     requestToggleAudio: (userId: UserId, shouldMute?: boolean) => void;
     requestMute: (userId: UserId) => void;
     requestUnmute: (userId: UserId) => void;
+    removeUser: (userId: UserId) => void;
+    listUsers: () => import("./types").User[];
+    showCaptions: () => void;
+    hideCaptions: () => void;
+    toggleCaptions: (show?: boolean) => void;
+    configureCaptions: (options: Partial<CaptionsOptions>) => void;
+    raiseHand: () => void;
+    lowerHand: (target?: UserId) => void;
+    allowBroadcast: (userId: UserId) => void;
+    disallowBroadcast: (userId: UserId) => void;
+    allowScreenshare: (userId: UserId) => void;
+    disallowScreenshare: (userId: UserId) => void;
 }