mediasfu-angular 1.0.0

package/dist/esm2022/lib/methods/utils/generate-random-participants.service.mjs

@@ -0,0 +1,99 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class GenerateRandomParticipants {
+    /**
+     * Generates a list of random participants with specified options.
+     *
+     * @param {Object} options - The options for generating participants.
+     * @param {string} options.member - The member to include in the participants list.
+     * @param {string} [options.coHost=""] - The co-host to include in the participants list.
+     * @param {string} options.host - The host to include in the participants list.
+     * @param {boolean} [options.forChatBroadcast=false] - Whether the participants are for a chat broadcast.
+     * @returns {Participant[]} An array of generated participants.
+     */
+    generateRandomParticipants({ member, coHost = '', host, forChatBroadcast = false, }) {
+        const participants = [];
+        let names = [
+            'Alice',
+            'Bob',
+            'Charlie',
+            'David',
+            'Eve',
+            'Frank',
+            'Grace',
+            'Hank',
+            'Ivy',
+            'Jack',
+            'Kate',
+            'Liam',
+            'Mia',
+            'Nina',
+            'Olivia',
+            'Pete',
+            'Quinn',
+            'Rachel',
+            'Steve',
+            'Tina',
+            'Ursula',
+            'Vince',
+            'Wendy',
+            'Xander',
+            'Yvonne',
+            'Zack',
+        ];
+        // Limit names to 2 for chat broadcast
+        if (forChatBroadcast) {
+            names.splice(2);
+        }
+        // Place member, coHost, and host at the beginning if not already included
+        if (!names.includes(member)) {
+            names.unshift(member);
+        }
+        if (!names.includes(coHost) && !forChatBroadcast) {
+            names.unshift(coHost);
+        }
+        if (!names.includes(host)) {
+            names.unshift(host);
+        }
+        // Limit names to 2 for chat broadcast
+        if (forChatBroadcast) {
+            names.splice(2);
+        }
+        // Remove names of length 1 or less
+        names = names.filter((name) => name.length > 1);
+        // Shuffle the names array to ensure unique names for each participant
+        const shuffledNames = [...names];
+        for (let i = shuffledNames.length - 1; i > 0; i--) {
+            const j = Math.floor(Math.random() * (i + 1));
+            [shuffledNames[i], shuffledNames[j]] = [shuffledNames[j], shuffledNames[i]];
+        }
+        let hasLevel2Participant = false;
+        // Generate participant objects
+        for (let i = 0; i < shuffledNames.length; i++) {
+            const randomName = shuffledNames[i];
+            const randomLevel = hasLevel2Participant ? '1' : randomName == host ? '2' : '1'; // Set islevel to '2' only once
+            const randomMuted = forChatBroadcast ? true : Math.random() < 0.5; // Set muted to false for chat broadcast
+            if (randomLevel === '2') {
+                hasLevel2Participant = true;
+            }
+            participants.push({
+                name: randomName,
+                islevel: randomLevel,
+                muted: randomMuted,
+                id: i.toString(),
+                audioID: `audio-${i}`,
+                videoID: `video-${i}`,
+            });
+        }
+        return participants;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: GenerateRandomParticipants, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: GenerateRandomParticipants, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: GenerateRandomParticipants, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"generate-random-participants.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/methods/utils/generate-random-participants.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Participant } from '../../@types/types';\nexport interface GenerateRandomParticipantsOptions {\n  member: string;\n  coHost?: string;\n  host: string;\n  forChatBroadcast?: boolean;\n}\n\n// Export the type definition for the function\nexport type GenerateRandomParticipantsType = (\n  options: GenerateRandomParticipantsOptions,\n) => Participant[];\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class GenerateRandomParticipants {\n  /**\n   * Generates a list of random participants with specified options.\n   *\n   * @param {Object} options - The options for generating participants.\n   * @param {string} options.member - The member to include in the participants list.\n   * @param {string} [options.coHost=\"\"] - The co-host to include in the participants list.\n   * @param {string} options.host - The host to include in the participants list.\n   * @param {boolean} [options.forChatBroadcast=false] - Whether the participants are for a chat broadcast.\n   * @returns {Participant[]} An array of generated participants.\n   */\n  generateRandomParticipants({\n    member,\n    coHost = '',\n    host,\n    forChatBroadcast = false,\n  }: GenerateRandomParticipantsOptions): Participant[] {\n    const participants: Participant[] = [];\n    let names = [\n      'Alice',\n      'Bob',\n      'Charlie',\n      'David',\n      'Eve',\n      'Frank',\n      'Grace',\n      'Hank',\n      'Ivy',\n      'Jack',\n      'Kate',\n      'Liam',\n      'Mia',\n      'Nina',\n      'Olivia',\n      'Pete',\n      'Quinn',\n      'Rachel',\n      'Steve',\n      'Tina',\n      'Ursula',\n      'Vince',\n      'Wendy',\n      'Xander',\n      'Yvonne',\n      'Zack',\n    ];\n\n    // Limit names to 2 for chat broadcast\n    if (forChatBroadcast) {\n      names.splice(2);\n    }\n\n    // Place member, coHost, and host at the beginning if not already included\n    if (!names.includes(member)) {\n      names.unshift(member);\n    }\n    if (!names.includes(coHost) && !forChatBroadcast) {\n      names.unshift(coHost);\n    }\n    if (!names.includes(host)) {\n      names.unshift(host);\n    }\n\n    // Limit names to 2 for chat broadcast\n    if (forChatBroadcast) {\n      names.splice(2);\n    }\n\n    // Remove names of length 1 or less\n    names = names.filter((name) => name.length > 1);\n\n    // Shuffle the names array to ensure unique names for each participant\n    const shuffledNames = [...names];\n    for (let i = shuffledNames.length - 1; i > 0; i--) {\n      const j = Math.floor(Math.random() * (i + 1));\n      [shuffledNames[i], shuffledNames[j]] = [shuffledNames[j], shuffledNames[i]];\n    }\n\n    let hasLevel2Participant = false;\n\n    // Generate participant objects\n    for (let i = 0; i < shuffledNames.length; i++) {\n      const randomName = shuffledNames[i];\n      const randomLevel = hasLevel2Participant ? '1' : randomName == host ? '2' : '1'; // Set islevel to '2' only once\n      const randomMuted = forChatBroadcast ? true : Math.random() < 0.5; // Set muted to false for chat broadcast\n\n      if (randomLevel === '2') {\n        hasLevel2Participant = true;\n      }\n\n      participants.push({\n        name: randomName,\n        islevel: randomLevel,\n        muted: randomMuted,\n        id: i.toString(),\n        audioID: `audio-${i}`,\n        videoID: `video-${i}`,\n      });\n    }\n\n    return participants;\n  }\n}\n"]}

package/dist/esm2022/lib/methods/utils/generate-random-polls.service.mjs

@@ -0,0 +1,52 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class GenerateRandomPolls {
+    /**
+     * Generates an array of random poll objects.
+     *
+     * @param {GenerateRandomPollsOptions} options - An object containing the number of polls to generate.
+     * @param {number} options.numberOfPolls - The number of random polls to generate.
+     * @returns {Poll[]} An array of random poll objects.
+     */
+    generateRandomPolls({ numberOfPolls }) {
+        const pollTypes = ['trueFalse', 'yesNo', 'custom'];
+        const polls = [];
+        for (let i = 0; i < numberOfPolls; i++) {
+            const type = pollTypes[Math.floor(Math.random() * pollTypes.length)];
+            let options;
+            switch (type) {
+                case 'trueFalse':
+                    options = ['True', 'False'];
+                    break;
+                case 'yesNo':
+                    options = ['Yes', 'No'];
+                    break;
+                case 'custom':
+                    options = Array.from({ length: Math.floor(Math.random() * 5) + 2 }, (_, idx) => `Option ${idx + 1}`);
+                    break;
+                default:
+                    options = [];
+            }
+            const poll = {
+                id: `${i + 1}`,
+                question: `Random Question ${i + 1}`,
+                type,
+                options,
+                votes: Array(options.length).fill(0),
+                status: 'inactive', // or 'active'
+                voters: {},
+            };
+            polls.push(poll);
+        }
+        return polls;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: GenerateRandomPolls, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: GenerateRandomPolls, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: GenerateRandomPolls, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2VuZXJhdGUtcmFuZG9tLXBvbGxzLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tZWRpYXNmdS1hbmd1bGFyL3NyYy9saWIvbWV0aG9kcy91dGlscy9nZW5lcmF0ZS1yYW5kb20tcG9sbHMuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQVkzQyxNQUFNLE9BQU8sbUJBQW1CO0lBQzlCOzs7Ozs7T0FNRztJQUNILG1CQUFtQixDQUFDLEVBQUUsYUFBYSxFQUE4QjtRQUMvRCxNQUFNLFNBQVMsR0FBYSxDQUFDLFdBQVcsRUFBRSxPQUFPLEVBQUUsUUFBUSxDQUFDLENBQUM7UUFDN0QsTUFBTSxLQUFLLEdBQVcsRUFBRSxDQUFDO1FBRXpCLEtBQUssSUFBSSxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUMsR0FBRyxhQUFhLEVBQUUsQ0FBQyxFQUFFLEVBQUUsQ0FBQztZQUN2QyxNQUFNLElBQUksR0FBRyxTQUFTLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsTUFBTSxFQUFFLEdBQUcsU0FBUyxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUM7WUFDckUsSUFBSSxPQUFpQixDQUFDO1lBRXRCLFFBQVEsSUFBSSxFQUFFLENBQUM7Z0JBQ2IsS0FBSyxXQUFXO29CQUNkLE9BQU8sR0FBRyxDQUFDLE1BQU0sRUFBRSxPQUFPLENBQUMsQ0FBQztvQkFDNUIsTUFBTTtnQkFDUixLQUFLLE9BQU87b0JBQ1YsT0FBTyxHQUFHLENBQUMsS0FBSyxFQUFFLElBQUksQ0FBQyxDQUFDO29CQUN4QixNQUFNO2dCQUNSLEtBQUssUUFBUTtvQkFDWCxPQUFPLEdBQUcsS0FBSyxDQUFDLElBQUksQ0FDbEIsRUFBRSxNQUFNLEVBQUUsSUFBSSxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsTUFBTSxFQUFFLEdBQUcsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxFQUFFLEVBQzdDLENBQUMsQ0FBQyxFQUFFLEdBQUcsRUFBRSxFQUFFLENBQUMsVUFBVSxHQUFHLEdBQUcsQ0FBQyxFQUFFLENBQ2hDLENBQUM7b0JBQ0YsTUFBTTtnQkFDUjtvQkFDRSxPQUFPLEdBQUcsRUFBRSxDQUFDO1lBQ2pCLENBQUM7WUFFRCxNQUFNLElBQUksR0FBUztnQkFDakIsRUFBRSxFQUFFLEdBQUcsQ0FBQyxHQUFHLENBQUMsRUFBRTtnQkFDZCxRQUFRLEVBQUUsbUJBQW1CLENBQUMsR0FBRyxDQUFDLEVBQUU7Z0JBQ3BDLElBQUk7Z0JBQ0osT0FBTztnQkFDUCxLQUFLLEVBQUUsS0FBSyxDQUFDLE9BQU8sQ0FBQyxNQUFNLENBQUMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDO2dCQUNwQyxNQUFNLEVBQUUsVUFBVSxFQUFFLGNBQWM7Z0JBQ2xDLE1BQU0sRUFBRSxFQUFFO2FBQ1gsQ0FBQztZQUVGLEtBQUssQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7UUFDbkIsQ0FBQztRQUVELE9BQU8sS0FBSyxDQUFDO0lBQ2YsQ0FBQzt1R0EvQ1UsbUJBQW1COzJHQUFuQixtQkFBbUIsY0FGbEIsTUFBTTs7MkZBRVAsbUJBQW1CO2tCQUgvQixVQUFVO21CQUFDO29CQUNWLFVBQVUsRUFBRSxNQUFNO2lCQUNuQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IFBvbGwgfSBmcm9tICcuLi8uLi9AdHlwZXMvdHlwZXMnO1xuZXhwb3J0IGludGVyZmFjZSBHZW5lcmF0ZVJhbmRvbVBvbGxzT3B0aW9ucyB7XG4gIG51bWJlck9mUG9sbHM6IG51bWJlcjtcbn1cblxuLy8gRXhwb3J0IHRoZSB0eXBlIGRlZmluaXRpb24gZm9yIHRoZSBmdW5jdGlvblxuZXhwb3J0IHR5cGUgR2VuZXJhdGVSYW5kb21Qb2xsc1R5cGUgPSAob3B0aW9uczogR2VuZXJhdGVSYW5kb21Qb2xsc09wdGlvbnMpID0+IFBvbGxbXTtcblxuQEluamVjdGFibGUoe1xuICBwcm92aWRlZEluOiAncm9vdCcsXG59KVxuZXhwb3J0IGNsYXNzIEdlbmVyYXRlUmFuZG9tUG9sbHMge1xuICAvKipcbiAgICogR2VuZXJhdGVzIGFuIGFycmF5IG9mIHJhbmRvbSBwb2xsIG9iamVjdHMuXG4gICAqXG4gICAqIEBwYXJhbSB7R2VuZXJhdGVSYW5kb21Qb2xsc09wdGlvbnN9IG9wdGlvbnMgLSBBbiBvYmplY3QgY29udGFpbmluZyB0aGUgbnVtYmVyIG9mIHBvbGxzIHRvIGdlbmVyYXRlLlxuICAgKiBAcGFyYW0ge251bWJlcn0gb3B0aW9ucy5udW1iZXJPZlBvbGxzIC0gVGhlIG51bWJlciBvZiByYW5kb20gcG9sbHMgdG8gZ2VuZXJhdGUuXG4gICAqIEByZXR1cm5zIHtQb2xsW119IEFuIGFycmF5IG9mIHJhbmRvbSBwb2xsIG9iamVjdHMuXG4gICAqL1xuICBnZW5lcmF0ZVJhbmRvbVBvbGxzKHsgbnVtYmVyT2ZQb2xscyB9OiBHZW5lcmF0ZVJhbmRvbVBvbGxzT3B0aW9ucyk6IFBvbGxbXSB7XG4gICAgY29uc3QgcG9sbFR5cGVzOiBzdHJpbmdbXSA9IFsndHJ1ZUZhbHNlJywgJ3llc05vJywgJ2N1c3RvbSddO1xuICAgIGNvbnN0IHBvbGxzOiBQb2xsW10gPSBbXTtcblxuICAgIGZvciAobGV0IGkgPSAwOyBpIDwgbnVtYmVyT2ZQb2xsczsgaSsrKSB7XG4gICAgICBjb25zdCB0eXBlID0gcG9sbFR5cGVzW01hdGguZmxvb3IoTWF0aC5yYW5kb20oKSAqIHBvbGxUeXBlcy5sZW5ndGgpXTtcbiAgICAgIGxldCBvcHRpb25zOiBzdHJpbmdbXTtcblxuICAgICAgc3dpdGNoICh0eXBlKSB7XG4gICAgICAgIGNhc2UgJ3RydWVGYWxzZSc6XG4gICAgICAgICAgb3B0aW9ucyA9IFsnVHJ1ZScsICdGYWxzZSddO1xuICAgICAgICAgIGJyZWFrO1xuICAgICAgICBjYXNlICd5ZXNObyc6XG4gICAgICAgICAgb3B0aW9ucyA9IFsnWWVzJywgJ05vJ107XG4gICAgICAgICAgYnJlYWs7XG4gICAgICAgIGNhc2UgJ2N1c3RvbSc6XG4gICAgICAgICAgb3B0aW9ucyA9IEFycmF5LmZyb20oXG4gICAgICAgICAgICB7IGxlbmd0aDogTWF0aC5mbG9vcihNYXRoLnJhbmRvbSgpICogNSkgKyAyIH0sXG4gICAgICAgICAgICAoXywgaWR4KSA9PiBgT3B0aW9uICR7aWR4ICsgMX1gLFxuICAgICAgICAgICk7XG4gICAgICAgICAgYnJlYWs7XG4gICAgICAgIGRlZmF1bHQ6XG4gICAgICAgICAgb3B0aW9ucyA9IFtdO1xuICAgICAgfVxuXG4gICAgICBjb25zdCBwb2xsOiBQb2xsID0ge1xuICAgICAgICBpZDogYCR7aSArIDF9YCxcbiAgICAgICAgcXVlc3Rpb246IGBSYW5kb20gUXVlc3Rpb24gJHtpICsgMX1gLFxuICAgICAgICB0eXBlLFxuICAgICAgICBvcHRpb25zLFxuICAgICAgICB2b3RlczogQXJyYXkob3B0aW9ucy5sZW5ndGgpLmZpbGwoMCksXG4gICAgICAgIHN0YXR1czogJ2luYWN0aXZlJywgLy8gb3IgJ2FjdGl2ZSdcbiAgICAgICAgdm90ZXJzOiB7fSxcbiAgICAgIH07XG5cbiAgICAgIHBvbGxzLnB1c2gocG9sbCk7XG4gICAgfVxuXG4gICAgcmV0dXJuIHBvbGxzO1xuICB9XG59XG4iXX0=

package/dist/esm2022/lib/methods/utils/generate-random-request-list.service.mjs

@@ -0,0 +1,54 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class GenerateRandomRequestList {
+    /**
+     * Generates a list of random requests for participants, excluding the host and co-host.
+     *
+     * @param {GenerateRandomRequestListOptions} options - The options for generating the request list.
+     * @param {Participant[]} options.participants - The list of participants.
+     * @param {string} options.hostName - The name of the host.
+     * @param {string} options.coHostName - The name of the co-host.
+     * @param {number} options.numberOfRequests - The number of requests to generate for each participant.
+     * @returns {Request[]} The generated list of requests.
+     */
+    generateRandomRequestList({ participants, hostName, coHostName, numberOfRequests, }) {
+        // Filter out the host and co-host from the participants
+        const filteredParticipants = participants.filter((participant) => participant.name !== hostName && participant.name !== coHostName);
+        // Create an array with three possible request icons
+        const requestIcons = ['fa-video', 'fa-desktop', 'fa-microphone'];
+        // Shuffle the request icons array to ensure unique icons for each participant and randomly select a minimum of 1 and a maximum of 3 icons
+        for (let i = requestIcons.length - 1; i > 0; i--) {
+            const j = Math.floor(Math.random() * (i + 1));
+            [requestIcons[i], requestIcons[j]] = [requestIcons[j], requestIcons[i]];
+        }
+        // Generate unique requests for each participant with unique icons
+        const requestList = filteredParticipants.flatMap((participant) => {
+            const uniqueIcons = new Set(); // To ensure unique icons for each participant
+            const requests = [];
+            for (let i = 0; i < numberOfRequests; i++) {
+                let randomIcon;
+                do {
+                    randomIcon = requestIcons[Math.floor(Math.random() * requestIcons.length)];
+                } while (uniqueIcons.has(randomIcon));
+                uniqueIcons.add(randomIcon);
+                requests.push({
+                    id: participant.id || '',
+                    name: participant.name.toLowerCase().replace(/\s/g, '_'),
+                    icon: randomIcon,
+                    username: participant.name.toLowerCase().replace(/\s/g, '_'),
+                });
+            }
+            return requests;
+        });
+        return requestList;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: GenerateRandomRequestList, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: GenerateRandomRequestList, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: GenerateRandomRequestList, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/methods/utils/generate-random-waiting-room-list.service.mjs

@@ -0,0 +1,38 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class GenerateRandomWaitingRoomList {
+    /**
+     * Generates a random list of participants for a waiting room.
+     *
+     * @param options - Configuration options for generating the waiting room list.
+     * @returns An array of `WaitingRoomParticipant` objects, each with a random name, mute status, and unique ID.
+     *
+     * @example
+     * const options = {};
+     * const waitingRoomList = generateRandomWaitingRoomList(options);
+     * console.log(waitingRoomList);
+     */
+    generateRandomWaitingRoomList() {
+        // Array of random names to assign to participants in the waiting room
+        const names = ['Dimen', 'Nore', 'Ker', 'Lor', 'Mik'];
+        // Loop through the names array and add participants to the waiting room list
+        const waitingRoomList = [];
+        for (let i = 0; i < names.length; i++) {
+            const randomName = names[i];
+            waitingRoomList.push({
+                name: randomName,
+                id: i.toString(),
+            });
+        }
+        return waitingRoomList;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: GenerateRandomWaitingRoomList, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: GenerateRandomWaitingRoomList, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: GenerateRandomWaitingRoomList, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/methods/utils/get-modal-position.util.mjs

@@ -0,0 +1,22 @@
+/**
+ * Gets the style for positioning a modal based on the specified position.
+ * @function
+ * @param {string} position - The desired position for the modal ('center', 'topLeft', 'topRight', 'bottomLeft', 'bottomRight').
+ * @returns {ModalPositionStyle} - The style object for positioning the modal.
+ */
+export function getModalPosition({ position }) {
+    switch (position) {
+        case 'center':
+            return { justifyContent: 'center', alignItems: 'center' };
+        case 'topLeft':
+            return { justifyContent: 'flex-start', alignItems: 'flex-start' };
+        case 'topRight':
+            return { justifyContent: 'flex-start', alignItems: 'flex-end' };
+        case 'bottomLeft':
+            return { justifyContent: 'flex-end', alignItems: 'flex-start' };
+        case 'bottomRight':
+        default:
+            return { justifyContent: 'flex-end', alignItems: 'flex-end' };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/methods/utils/get-overlay-position.util.mjs

@@ -0,0 +1,21 @@
+/**
+ * Gets the style for positioning an overlay based on the specified position.
+ * @function
+ * @param {string} position - The desired position for the overlay ('topLeft', 'topRight', 'bottomLeft', 'bottomRight').
+ * @returns {OverlayPositionStyle} - The style object for positioning the overlay.
+ */
+export function getOverlayPosition({ position }) {
+    switch (position) {
+        case 'topLeft':
+            return { top: 0, left: 0 };
+        case 'topRight':
+            return { top: 0, right: 0 };
+        case 'bottomLeft':
+            return { bottom: 0, left: 0 };
+        case 'bottomRight':
+            return { bottom: 0, right: 0 };
+        default:
+            return {};
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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