mediasfu-shared 1.0.1 → 1.0.2

package/src/methods/utils/generateRandomMessages.ts

@@ -0,0 +1,70 @@
+import type { Message, Participant } from '../../types/shared-base-types';
+
+export interface GenerateRandomMessagesOptions {
+  participants: Participant[];
+  member: string;
+  coHost?: string;
+  host: string;
+  forChatBroadcast?: boolean;
+}
+
+export type GenerateRandomMessagesType = (options: GenerateRandomMessagesOptions) => Message[];
+
+export const generateRandomMessages = ({
+  participants,
+  member,
+  coHost = '',
+  host,
+  forChatBroadcast = false,
+}: GenerateRandomMessagesOptions): Message[] => {
+  const messages: Message[] = [];
+
+  const getRandomReceiver = (sender: string): string => {
+    const potentialReceivers = participants.filter((participant) => participant.name !== sender);
+    const randomReceiver = potentialReceivers[Math.floor(Math.random() * potentialReceivers.length)];
+    return randomReceiver?.name || '';
+  };
+
+  let refNames: string[] = [];
+  if (forChatBroadcast) {
+    refNames = [member, host];
+  } else if (coHost) {
+    refNames = [
+      member,
+      coHost,
+      host,
+      ...participants.map((participant) => participant.name).filter((name): name is string => name !== undefined),
+    ];
+  } else {
+    refNames = [
+      member,
+      host,
+      ...participants.map((participant) => participant.name).filter((name): name is string => name !== undefined),
+    ];
+  }
+
+  refNames = [...new Set(refNames)];
+
+  let timeIncrement = 0;
+  refNames.forEach((sender) => {
+    messages.push({
+      sender,
+      receivers: [getRandomReceiver(sender)],
+      message: `Direct message from ${sender}`,
+      timestamp: new Date(Date.now() + timeIncrement).toLocaleTimeString(),
+      group: false,
+    });
+
+    messages.push({
+      sender,
+      receivers: participants.map((participant) => participant.name).filter((name): name is string => name !== undefined),
+      message: `Group message from ${sender}`,
+      timestamp: new Date(Date.now() + timeIncrement).toLocaleTimeString(),
+      group: true,
+    });
+
+    timeIncrement += 15000;
+  });
+
+  return messages;
+};

package/src/methods/utils/generateRandomParticipants.ts

@@ -0,0 +1,100 @@
+import type { Participant } from '../../types/shared-base-types';
+
+export interface GenerateRandomParticipantsOptions {
+  member: string;
+  coHost?: string;
+  host: string;
+  forChatBroadcast?: boolean;
+}
+
+export type GenerateRandomParticipantsType = (
+  options: GenerateRandomParticipantsOptions,
+) => Participant[];
+
+export const generateRandomParticipants = ({
+  member,
+  coHost = '',
+  host,
+  forChatBroadcast = false,
+}: GenerateRandomParticipantsOptions): Participant[] => {
+  const participants: Participant[] = [];
+  let names: string[] = [
+    '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',
+  ];
+
+  if (forChatBroadcast) {
+    names.splice(2);
+  }
+
+  if (!names.includes(member)) {
+    names.unshift(member);
+  }
+
+  if (!names.includes(coHost) && !forChatBroadcast) {
+    names.unshift(coHost);
+  }
+
+  if (!names.includes(host)) {
+    names.unshift(host);
+  }
+
+  if (forChatBroadcast) {
+    names.splice(2);
+  }
+
+  names = names.filter((name) => name.length > 1);
+
+  const shuffledNames = [...names];
+  for (let index = shuffledNames.length - 1; index > 0; index -= 1) {
+    const randomIndex = Math.floor(Math.random() * (index + 1));
+    [shuffledNames[index], shuffledNames[randomIndex]] = [shuffledNames[randomIndex], shuffledNames[index]];
+  }
+
+  let hasLevel2Participant = false;
+
+  for (let index = 0; index < shuffledNames.length; index += 1) {
+    const randomName = shuffledNames[index];
+    const randomLevel = hasLevel2Participant ? '1' : randomName === host ? '2' : '1';
+    const randomMuted = forChatBroadcast ? true : Math.random() < 0.5;
+
+    if (randomLevel === '2') {
+      hasLevel2Participant = true;
+    }
+
+    participants.push({
+      name: randomName,
+      islevel: randomLevel,
+      muted: randomMuted,
+      id: index.toString(),
+      audioID: `audio-${index}`,
+      videoID: `video-${index}`,
+    });
+  }
+
+  return participants;
+};

package/src/methods/utils/generateRandomPolls.ts

@@ -0,0 +1,43 @@
+import type { Poll } from '../../types/shared-base-types';
+
+export interface GenerateRandomPollsOptions {
+  numberOfPolls: number;
+}
+
+export type GenerateRandomPollsType = (options: GenerateRandomPollsOptions) => Poll[];
+
+export const generateRandomPolls = ({ numberOfPolls }: GenerateRandomPollsOptions): Poll[] => {
+  const pollTypes: string[] = ['trueFalse', 'yesNo', 'custom'];
+  const polls: Poll[] = [];
+
+  for (let index = 0; index < numberOfPolls; index += 1) {
+    const type = pollTypes[Math.floor(Math.random() * pollTypes.length)];
+    let options: string[];
+
+    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 }, (_, optionIndex) => `Option ${optionIndex + 1}`);
+        break;
+      default:
+        options = [];
+    }
+
+    polls.push({
+      id: `${index + 1}`,
+      question: `Random Question ${index + 1}`,
+      type,
+      options,
+      votes: Array(options.length).fill(0),
+      status: 'inactive',
+      voters: {},
+    });
+  }
+
+  return polls;
+};

package/src/methods/utils/generateRandomRequestList.ts

@@ -0,0 +1,51 @@
+import type { Participant, Request } from '../../types/shared-base-types';
+
+export interface GenerateRandomRequestListOptions {
+  participants: Participant[];
+  hostName: string;
+  coHostName?: string;
+  numberOfRequests: number;
+}
+
+export type GenerateRandomRequestListType = (options: GenerateRandomRequestListOptions) => Request[];
+
+export const generateRandomRequestList = ({
+  participants,
+  hostName,
+  coHostName,
+  numberOfRequests,
+}: GenerateRandomRequestListOptions): Request[] => {
+  const filteredParticipants = participants.filter(
+    (participant) => participant.name !== hostName && participant.name !== coHostName,
+  );
+
+  const requestIcons = ['fa-video', 'fa-desktop', 'fa-microphone'];
+
+  for (let index = requestIcons.length - 1; index > 0; index -= 1) {
+    const randomIndex = Math.floor(Math.random() * (index + 1));
+    [requestIcons[index], requestIcons[randomIndex]] = [requestIcons[randomIndex], requestIcons[index]];
+  }
+
+  return filteredParticipants.flatMap((participant) => {
+    const uniqueIcons = new Set<string>();
+    const requests: Request[] = [];
+
+    for (let index = 0; index < numberOfRequests; index += 1) {
+      let randomIcon: string;
+      do {
+        randomIcon = requestIcons[Math.floor(Math.random() * requestIcons.length)];
+      } while (uniqueIcons.has(randomIcon));
+
+      uniqueIcons.add(randomIcon);
+
+      requests.push({
+        id: participant.id || '',
+        name: participant.name ? participant.name.toLowerCase().replace(/\s/g, '_') : '',
+        icon: randomIcon,
+        username: participant.name ? participant.name.toLowerCase().replace(/\s/g, '_') : '',
+      });
+    }
+
+    return requests;
+  });
+};

package/src/methods/utils/generateRandomWaitingRoomList.ts

@@ -0,0 +1,17 @@
+import type { WaitingRoomParticipant } from '../../types/shared-base-types';
+
+export type GenerateRandomWaitingRoomListType = () => WaitingRoomParticipant[];
+
+export const generateRandomWaitingRoomList = (): WaitingRoomParticipant[] => {
+  const names = ['Dimen', 'Nore', 'Ker', 'Lor', 'Mik'];
+
+  const waitingRoomList: WaitingRoomParticipant[] = [];
+  for (let index = 0; index < names.length; index += 1) {
+    waitingRoomList.push({
+      name: names[index],
+      id: index.toString(),
+    });
+  }
+
+  return waitingRoomList;
+};

package/src/methods/utils/getModalPosition.ts

@@ -0,0 +1,23 @@
+import { ModalPositionStyle } from '../../types/shared-base-types';
+
+export interface GetModalPositionOptions {
+  position: string;
+}
+
+export type GetModalPositionType = (options: GetModalPositionOptions) => ModalPositionStyle;
+
+export const getModalPosition = ({ position }: GetModalPositionOptions): ModalPositionStyle => {
+  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' };
+  }
+};

package/src/methods/utils/getOverlayPosition.ts

@@ -0,0 +1,37 @@
+import type { OverlayPositionStyle } from '../../types/types';
+
+export interface GetOverlayPositionOptions {
+  position: string;
+}
+
+export type GetOverlayPositionType = (options: GetOverlayPositionOptions) => OverlayPositionStyle;
+
+/**
+ * Maps a symbolic overlay position to CSS-style edge coordinates.
+ *
+ * This is used by display card components to anchor badges, audio indicators,
+ * or auxiliary overlays to a participant tile corner.
+ *
+ * @param options Overlay position options.
+ * @returns A partial coordinate object suitable for inline style application.
+ *
+ * @example
+ * ```typescript
+ * const style = getOverlayPosition({ position: 'bottomRight' });
+ * // style === { bottom: 0, right: 0 }
+ * ```
+ */
+export const getOverlayPosition = ({ position }: GetOverlayPositionOptions): OverlayPositionStyle => {
+  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 {};
+  }
+};