@webex/plugin-meetings 3.0.0-beta.7 → 3.0.0-beta.71

package/dist/types/controls-options-manager/constants.d.ts

@@ -0,0 +1,4 @@
+declare const ENABLED = "enabled";
+declare const CAN_SET = "canSet";
+declare const CAN_UNSET = "canUnset";
+export { ENABLED, CAN_SET, CAN_UNSET };

package/dist/types/controls-options-manager/enums.d.ts

@@ -0,0 +1,6 @@
+declare enum Setting {
+    disallowUnmute = "DisallowUnmute",
+    muteOnEntry = "MuteOnEntry",
+    muted = "Muted"
+}
+export default Setting;

package/dist/types/controls-options-manager/index.d.ts

@@ -0,0 +1,128 @@
+import MeetingRequest from '../meeting/request';
+/**
+ * docs
+ * https://sqbu-github.cisco.com/pages/WebExSquared/locus/guides/mute.html
+ * https://confluence-eng-gpk2.cisco.com/conf/display/LOCUS/Hard+Mute+and+Audio+Privacy#HardMuteandAudioPrivacy-SelfMuteonEntry
+ * https://confluence-eng-gpk2.cisco.com/conf/pages/viewpage.action?spaceKey=UC&title=WEBEX-124454%3A+UCF%3A+Hard+mute+support+for+Teams+joining+Webex+meeting
+ * https://jira-eng-gpk2.cisco.com/jira/browse/SPARK-180867
+ * https://jira-eng-gpk2.cisco.com/jira/browse/SPARK-393351
+ */
+/**
+ * @description ControlsOptionsManager is responsible for handling the behavior of participant controls when somebody joins a meeting
+ * @export
+ * @private
+ * @class Recording
+ */
+export default class ControlsOptionsManager {
+    /**
+     * @instance
+     * @type {MeetingRequest}
+     * @private
+     * @memberof ControlsOptionsManager
+     */
+    private request;
+    /**
+     * @instance
+     * @type {Array}
+     * @private
+     * @memberof ControlsOptionsManager
+     */
+    private displayHints;
+    /**
+     * @instance
+     * @type {string}
+     * @private
+     * @memberof ControlsOptionsManager
+     */
+    private locusUrl;
+    /**
+     * @param {MeetingRequest} request
+     * @param {Object} options
+     * @constructor
+     * @memberof ControlsOptionsManager
+     */
+    constructor(request: MeetingRequest, options?: {
+        locusUrl: string;
+        displayHints?: Array<string>;
+    });
+    /**
+     * @param {MeetingRequest} request
+     * @returns {void}
+     * @private
+     * @memberof ControlsOptionsManager
+     */
+    private initialize;
+    /**
+     * @param {Object} options
+     * @returns {void}
+     * @public
+     * @memberof ControlsOptionsManager
+     */
+    set(options?: {
+        locusUrl: string;
+        displayHints?: Array<string>;
+    }): void;
+    /**
+     * @param {string} url
+     * @returns {void}
+     * @public
+     * @memberof ControlsOptionsManager
+     */
+    setLocusUrl(url: string): void;
+    /**
+     * @param {Array} hints
+     * @returns {void}
+     * @public
+     * @memberof ControlsOptionsManager
+     */
+    setDisplayHints(hints: Array<string>): void;
+    /**
+     * @returns {string}
+     * @public
+     * @memberof ControlsOptionsManager
+     */
+    getLocusUrl(): string;
+    /**
+     * @returns {Array}
+     * @public
+     * @memberof ControlsOptionsManager
+     */
+    getDisplayHints(): string[];
+    /**
+     * @param {Object} options
+     * @returns {void}
+     * @private
+     * @memberof ControlsOptionsManager
+     */
+    private extract;
+    /**
+     * @param {Setting} setting
+     * @private
+     * @memberof ControlsOptionsManager
+     * @returns {Promise}
+     */
+    private setControls;
+    /**
+     * @public
+     * @param {boolean} enabled
+     * @memberof ControlsOptionsManager
+     * @returns {Promise}
+     */
+    setMuteOnEntry(enabled: boolean): Promise<any>;
+    /**
+     * @public
+     * @param {boolean} enabled
+     * @memberof ControlsOptionsManager
+     * @returns {Promise}
+     */
+    setDisallowUnmute(enabled: boolean): Promise<any>;
+    /**
+     * @public
+     * @param {boolean} mutedEnabled
+     * @param {boolean} disallowUnmuteEnabled
+     * @param {boolean} muteOnEntryEnabled
+     * @memberof ControlsOptionsManager
+     * @returns {Promise}
+     */
+    setMuteAll(mutedEnabled: boolean, disallowUnmuteEnabled: boolean, muteOnEntryEnabled: boolean): Promise<any>;
+}

package/dist/types/controls-options-manager/util.d.ts

@@ -0,0 +1,9 @@
+declare const _default: {
+    canSetMuteOnEntry: (displayHints: string[]) => boolean;
+    canSetDisallowUnmute: (displayHints: string[]) => boolean;
+    canSetMuted: (displayHints: string[]) => boolean;
+    canUnsetMuteOnEntry: (displayHints: string[]) => boolean;
+    canUnsetDisallowUnmute: (displayHints: string[]) => boolean;
+    canUnsetMuted: (displayHints: string[]) => boolean;
+};
+export default _default;

package/dist/types/index.d.ts

@@ -0,0 +1,6 @@
+export default Meetings;
+export * as CONSTANTS from "./constants";
+export * as REACTIONS from "./reactions/reactions";
+export { RemoteMedia } from "./multistream/remoteMedia";
+export { default as TriggerProxy } from "./common/events/trigger-proxy";
+import Meetings from "./meetings";

package/dist/types/locus-info/controlsUtils.d.ts

@@ -0,0 +1,2 @@
+declare const ControlsUtils: any;
+export default ControlsUtils;

package/dist/types/locus-info/embeddedAppsUtils.d.ts

@@ -0,0 +1,2 @@
+declare const EmbeddedAppsUtils: any;
+export default EmbeddedAppsUtils;

package/dist/types/locus-info/fullState.d.ts

@@ -0,0 +1,2 @@
+declare const FullState: any;
+export default FullState;

package/dist/types/locus-info/hostUtils.d.ts

@@ -0,0 +1,2 @@
+declare const HostUtils: any;
+export default HostUtils;

package/dist/types/locus-info/index.d.ts

@@ -0,0 +1,276 @@
+import EventsScope from '../common/events/events-scope';
+/**
+ * @description LocusInfo extends ChildEmitter to convert locusInfo info a private emitter to parent object
+ * @export
+ * @private
+ * @class LocusInfo
+ */
+export default class LocusInfo extends EventsScope {
+    compareAndUpdateFlags: any;
+    emitChange: any;
+    locusParser: any;
+    meetingId: any;
+    parsedLocus: any;
+    updateMeeting: any;
+    webex: any;
+    aclUrl: any;
+    baseSequence: any;
+    created: any;
+    deltaParticipants: any;
+    identities: any;
+    membership: any;
+    participants: any;
+    participantsUrl: any;
+    replaces: any;
+    scheduledMeeting: any;
+    sequence: any;
+    controls: any;
+    conversationUrl: any;
+    embeddedApps: any;
+    fullState: any;
+    host: any;
+    info: any;
+    mediaShares: any;
+    replace: any;
+    url: any;
+    services: any;
+    /**
+     * Constructor
+     * @param {boolean} updateMeeting true if the meeting should be updated
+     * @param {object} webex
+     * @param {string} meetingId
+     * @returns {undefined}
+     */
+    constructor(updateMeeting: any, webex: any, meetingId: any);
+    /**
+     * Apply locus delta data to meeting
+     * @param {string} action Locus delta action
+     * @param {Locus} locus
+     * @param {Meeting} meeting
+     * @returns {undefined}
+     */
+    applyLocusDeltaData(action: string, locus: any, meeting: any): void;
+    /**
+     * Adds locus delta to parser's queue
+     * and registers a function handler
+     * to recieve parsed actions from queue.
+     * @param {Locus} locus
+     * @param {Meeting} meeting
+     * @returns {undefined}
+     */
+    handleLocusDelta(locus: any, meeting: any): void;
+    /**
+     * @param {Locus} locus
+     * @returns {undefined}
+     * @memberof LocusInfo
+     */
+    init(locus?: any): void;
+    /**
+     * @param {Object} locus
+     * @returns {undefined}
+     * @memberof LocusInfo
+     */
+    initialSetup(locus: object): void;
+    /**
+     * @param {Meeting} meeting
+     * @param {Object} data
+     * @returns {undefined}
+     * @memberof LocusInfo
+     */
+    parse(meeting: any, data: any): void;
+    /**
+     * @param {String} scope
+     * @param {String} eventName
+     * @param {Array} args
+     * @returns {undefined}
+     * @memberof LocusInfo
+     */
+    emitScoped(scope?: any, eventName?: string, args?: any): boolean;
+    /**
+     * updates the locus with full locus object
+     * @param {object} locus locus object
+     * @param {string} eventType particulat locus event
+     * @returns {object} null
+     * @memberof LocusInfo
+     */
+    onFullLocus(locus: any, eventType?: string): void;
+    /**
+     * @param {String} eventType
+     * @returns {undefined}
+     * @memberof LocusInfo
+     */
+    handleOneOnOneEvent(eventType: string): void;
+    /**
+     * @param {Object} locus
+     * @returns {undefined}
+     * @memberof LocusInfo
+     */
+    onDeltaLocus(locus: any): void;
+    /**
+     * @param {Object} locus
+     * @returns {undefined}
+     * @memberof LocusInfo
+     */
+    updateLocusInfo(locus: any): void;
+    /**
+     * @param {Array} participants
+     * @param {Object} self
+     * @returns {Array}
+     * @memberof LocusInfo
+     */
+    getLocusPartner(participants: Array<any>, self: any): any;
+    /**
+     * @returns {undefined}
+     * @memberof LocusInfo
+     */
+    isMeetingActive(): void;
+    /**
+     * checks if the host permissions have changed while in the meeting
+     * This would be the case if your role as host or moderator has been updated
+     * @returns {undefined}
+     * @memberof LocusInfo
+     */
+    compareAndUpdate(): void;
+    /**
+     * compared the self object to check if the user has host permissions
+     * @returns {undefined}
+     * @memberof LocusInfo
+     */
+    compareSelfAndHost(): void;
+    /**
+     * Update the deltaParticipants property of this object based on a list of
+     * provided participants.
+     *
+     * @param {Array} [participants] - The participants to update against.
+     * @returns {void}
+     */
+    updateParticipantDeltas(participants?: Array<any>): void;
+    /**
+     * update meeting's members
+     * @param {Object} participants new participants object
+     * @param {Boolean} isReplace is replace the whole members
+     * @returns {Array} updatedParticipants
+     * @memberof LocusInfo
+     */
+    updateParticipants(participants: object, isReplace?: boolean): void;
+    /**
+     * @param {Object} controls
+     * @returns {undefined}
+     * @memberof LocusInfo
+     */
+    updateControls(controls: object): void;
+    /**
+     * @param {String} conversationUrl
+     * @param {Object} info
+     * @returns {undefined}
+     * @memberof LocusInfo
+     */
+    updateConversationUrl(conversationUrl: string, info: any): void;
+    /**
+     * @param {Object} created
+     * @returns {undefined}
+     * @memberof LocusInfo
+     */
+    updateCreated(created: object): void;
+    /**
+     * @param {Object} services
+     * @returns {undefined}
+     * @memberof LocusInfo
+     */
+    updateServices(services: Record<'breakout' | 'record', {
+        url: string;
+    }>): void;
+    /**
+     * @param {Object} fullState
+     * @returns {undefined}
+     * @memberof LocusInfo
+     */
+    updateFullState(fullState: object): void;
+    /**
+     * handles when the locus.host is updated
+     * @param {Object} host the locus.host property
+     * @returns {undefined}
+     * @memberof LocusInfo
+     * emits internal event locus_info_update_host
+     */
+    updateHostInfo(host: object): void;
+    /**
+     * @param {Object} info
+     * @param {Object} self
+     * @returns {undefined}
+     * @memberof LocusInfo
+     */
+    updateMeetingInfo(info: object, self?: object): void;
+    /**
+     * @param {Object} embeddedApps
+     * @returns {undefined}
+     * @memberof LocusInfo
+     */
+    updateEmbeddedApps(embeddedApps: object): void;
+    /**
+     * handles when the locus.mediaShares is updated
+     * @param {Object} mediaShares the locus.mediaShares property
+     * @returns {undefined}
+     * @memberof LocusInfo
+     * emits internal event locus_info_update_media_shares
+     */
+    updateMediaShares(mediaShares: object): void;
+    /**
+     * @param {String} participantsUrl
+     * @returns {undefined}
+     * @memberof LocusInfo
+     */
+    updateParticipantsUrl(participantsUrl: string): void;
+    /**
+     * @param {Object} replace
+     * @returns {undefined}
+     * @memberof LocusInfo
+     */
+    updateReplace(replace: object): void;
+    /**
+     * handles when the locus.self is updated
+     * @param {Object} self the locus.mediaShares property
+     * @param {Array} participants the locus.participants property
+     * @returns {undefined}
+     * @memberof LocusInfo
+     * emits internal events self_admitted_guest, self_unadmitted_guest, locus_info_update_self
+     */
+    updateSelf(self: any, participants: Array<any>): void;
+    /**
+     * handles when the locus.url is updated
+     * @param {String} url
+     * @returns {undefined}
+     * emits internal event locus_info_update_url
+     */
+    updateLocusUrl(url: string): void;
+    /**
+     * @param {String} aclUrl
+     * @returns {undefined}
+     * @memberof LocusInfo
+     */
+    updateAclUrl(aclUrl: string): void;
+    /**
+     * @param {Number} baseSequence
+     * @returns {undefined}
+     * @memberof LocusInfo
+     */
+    updateBasequence(baseSequence: number): void;
+    /**
+     * @param {Number} sequence
+     * @returns {undefined}
+     * @memberof LocusInfo
+     */
+    updateSequence(sequence: number): void;
+    /**
+     * @param {Object} membership
+     * @returns {undefined}
+     * @memberof LocusInfo
+     */
+    updateMemberShip(membership: object): void;
+    /**
+     * @param {Array} identities
+     * @returns {undefined}
+     * @memberof LocusInfo
+     */
+    updateIdentifiers(identities: Array<any>): void;
+}

package/dist/types/locus-info/infoUtils.d.ts

@@ -0,0 +1,2 @@
+declare const InfoUtils: any;
+export default InfoUtils;

package/dist/types/locus-info/mediaSharesUtils.d.ts

@@ -0,0 +1,2 @@
+declare const MediaSharesUtils: any;
+export default MediaSharesUtils;

package/dist/types/locus-info/parser.d.ts

@@ -0,0 +1,212 @@
+/**
+ * Locus Delta Parser
+ * @private
+ * https://sqbu-github.cisco.com/WebExSquared/cloud-apps/wiki/Locus-Delta-Events
+ */
+export default class Parser {
+    static status: {
+        IDLE: string;
+        PAUSED: string;
+        WORKING: string;
+    };
+    static loci: {
+        EQ: string;
+        GT: string;
+        LT: string;
+        DESYNC: string;
+        USE_INCOMING: string;
+        USE_CURRENT: string;
+        ERROR: string;
+    };
+    queue: any;
+    workingCopy: any;
+    /**
+     * @constructs Parser
+     */
+    constructor();
+    /**
+     * Checks if two sequences overlap in time,
+     * the sequence with the higher minimum value is greater.
+     * Chooses sequence with most recent data.
+     * @param {Types~Locus} current
+     * @param {Types~Locus} incoming
+     * @returns {string} loci comparison state
+     */
+    static checkSequenceOverlap(current: any, incoming: any): any;
+    /**
+     * Checks if two sequences have unequal ranges.
+     * Chooses sequence with most larger range.
+     * @param {Types~Locus} current
+     * @param {Types~Locus} incoming
+     * @returns {object} loci comparison
+     */
+    static checkUnequalRanges(current: any, incoming: any): any;
+    /**
+     * Checks if either sequences has unique entries.
+     * Entries are considered unique if they do not overlap
+     * with other Loci sequences or range values.
+     * Chooses sequence with the unique entries.
+     * @param {Types~Locus} current
+     * @param {Types~Locus} incoming
+     * @returns {string} loci comparison state
+     */
+    static checkForUniqueEntries(current: any, incoming: any): any;
+    /**
+     * Checks both Locus Delta objects to see if they are
+     * out of sync with one another. If so sends a DESYNC
+     * request to the server.
+     * @param {Types~Locus} current
+     * @param {Types~Locus} incoming
+     * @returns {string} loci comparison state
+     */
+    static checkIfOutOfSync(current: any, incoming: any): any;
+    /**
+     * Compares two loci to determine which one contains the most recent state
+     * @instance
+     * @memberof Locus
+     * @param {Types~Locus} current
+     * @param {Types~Locus} incoming
+     * @returns {string} loci comparison state
+     */
+    static compare(current: any, incoming: any): string;
+    /**
+     * Compares two loci sequences (with delta params) and indicates what action
+     * to take.
+     * @instance
+     * @memberof Locus
+     * @param {Types~Locus} current
+     * @param {Types~Locus} incoming
+     * @private
+     * @returns {string} loci comparison state
+     */
+    private static compareDelta;
+    /**
+     * Compares Locus sequences
+     * @param {Types~Locus} current Current working copy
+     * @param {Types~Locus} incoming New Locus delta
+     * @returns {string}
+     */
+    static compareSequence(current: any, incoming: any): any;
+    /**
+     * Transates the result of a sequence comparison into an intended behavior
+     * @param {string} result
+     * @returns {string} Locus comparison action
+     */
+    static compareToAction(result: string): string;
+    /**
+     * Extracts a loci comparison from a string of data.
+     * @param {string} lociComparisonResult Comparison result with extra data
+     * @returns {string} Comparison of EQ, LT, GT, or DESYNC.
+     */
+    static extractComparisonState(lociComparisonResult: string): string;
+    /**
+     * @typedef {object} LociMetadata
+     * @property {number} start - Starting sequence number
+     * @property {number} end - Ending sequence number
+     * @property {number} first - First sequence number
+     * @property {number} last - Last sequence number
+     * @property {number} min - Minimum sequence number
+     * @property {number} max - Maximum sequence number
+     * @property {number} entries - Loci sequence entries
+     */
+    /**
+     * Metadata for Locus delta
+     * @param {Array.<number>} sequence Locus delta sequence
+     * @returns {LociMetadata} Locus Delta Metadata
+     */
+    static getMetaData(sequence: any): {
+        start: any;
+        end: any;
+        first: any;
+        last: any;
+        min: any;
+        max: any;
+        entries: any;
+    };
+    /**
+     * Compares two Locus delta objects and notes unique
+     * values contained within baseLoci.
+     * @param {LociMetadata} baseLoci
+     * @param {LociMetadata} otherLoci
+     * @returns {Array.<number>} List of unique sequences
+     */
+    static getUniqueSequences(baseLoci: any, otherLoci: any): number[];
+    /**
+     * Returns an array of numbers outside of a given range.
+     * @param {Array.<number>} list Array to filter
+     * @param {number} rangeStart Start of range
+     * @param {number} rangeEnd End of range
+     * @returns {Array.<number>} Array of numbers sorted ASC
+     */
+    static getNumbersOutOfRange(list: Array<number>, rangeStart: number, rangeEnd: number): number[];
+    /**
+     * Checks if newLoci or workingCopy is invalid.
+     * @param {Types~Locus} newLoci
+     * @returns {boolean}
+     */
+    isValidLocus(newLoci: any): boolean;
+    /**
+     * Determines if a paricular locus's sequence is empty
+     * @param {Types~Locus} locus
+     * @returns {bool}
+     */
+    static isSequenceEmpty(locus: any): boolean;
+    /**
+     * Determines if an object has basic
+     * structure of a locus object.
+     * @param {Types~Locus} loci
+     * @returns {boolean}
+     */
+    static isLoci(loci: any): boolean;
+    /**
+     * Processes next event in queue,
+     * if queue is empty sets status to idle.
+     * @returns {undefined}
+     */
+    nextEvent(): void;
+    /**
+     * Function handler for delta actions,
+     * is set by instance callee.
+     * @param {string} action Locus delta action
+     * @param {Types~Locus} locus Locus delta
+     * @returns {undefined}
+     */
+    onDeltaAction(action: string, locus: any): void;
+    /**
+     * Event handler for locus delta events
+     * @param {Types~Locus} loci Locus Delta
+     * @returns {undefined}
+     */
+    onDeltaEvent(loci: any): void;
+    /**
+     * Appends new data onto a string of existing data.
+     * @param {string} newData
+     * @param {string} oldData
+     * @returns {string}
+     */
+    static packComparisonResult(newData: string, oldData: string): string;
+    /**
+     * Pause locus processing
+     * @returns {undefined}
+     */
+    pause(): void;
+    /**
+     * Processes next locus delta in the queue,
+     * continues until the queue is empty
+     * or cleared.
+     * @returns {undefined}
+     */
+    processDeltaEvent(): void;
+    /**
+     * Resume from a paused state
+     * @returns {undefined}
+     */
+    resume(): void;
+    /**
+     * Gets related debug info for given error code
+     * @param {string} debugCode Debug code
+     * @param {string} comparison Locus comparison string
+     * @returns {object} Debug message
+     */
+    static getDebugMessage(debugCode: string, comparison: string): any;
+}

package/dist/types/locus-info/selfUtils.d.ts

@@ -0,0 +1,2 @@
+declare const SelfUtils: any;
+export default SelfUtils;