@wazo/sdk 0.38.22 → 0.39.0-beta.10

package/src/utils/sdp.ts

@@ -0,0 +1,119 @@
+import sdpParser from 'sdp-transform';
+
+export const getCandidates = (rawSdp: string | null | undefined): Record<string, any>[] => {
+  if (!rawSdp) {
+    return [];
+  }
+
+  const sdp: any = sdpParser.parse(rawSdp);
+
+  if (!sdp || !sdp.media) {
+    return [];
+  }
+
+  return sdp.media.map((media: any) => media.candidates).flat().filter((candidate: any) => !!candidate);
+};
+export const parseCandidate = (candidate?: string): Record<string, any> | null => {
+  if (!candidate) {
+    return null;
+  }
+
+  const result: any = sdpParser.parse(candidate.indexOf('a=') === 0 ? candidate : `a=${candidate}`);
+  return result.candidates ? result.candidates[0] : null;
+};
+
+const getSrflxOrRelay = (candidates: Record<string, any>[]): Record<string, any>[] => candidates.filter(candidate => candidate && (candidate.type === 'srflx' || candidate.type === 'relay'));
+
+export const areCandidateValid = (candidates: Record<string, any>[]): boolean => getSrflxOrRelay(candidates).length > 0;
+export const isSdpValid = (sdp: string | null | undefined): boolean => {
+  const candidates = getCandidates(sdp);
+  return areCandidateValid(candidates);
+};
+export const fixBundle = (sdp: string): string => {
+  const parsedSdp: any = sdpParser.parse(sdp);
+  const bundleIndex = parsedSdp.groups.findIndex((group: any) => group.type === 'BUNDLE');
+
+  if (bundleIndex !== -1) {
+    parsedSdp.groups[bundleIndex].mids = parsedSdp.media.map((media: any, index: any) => ('mid' in media ? media.mid : index)).join(' ');
+  }
+
+  return sdpParser.write(parsedSdp);
+};
+export const toggleVideoDirection = (sdp: string, direction: string | null | undefined): string => {
+  const parsedSdp: any = sdpParser.parse(sdp);
+  parsedSdp.media = parsedSdp.media.map((media: any) => ({ ...media,
+    ...(media.type === 'video' ? {
+      direction,
+    } : {}),
+  }));
+  return sdpParser.write(parsedSdp);
+};
+export const getVideoDirection = (sdp: string): string | null | undefined => {
+  const parsedSdp = sdpParser.parse(sdp);
+  const videoMedia = parsedSdp.media.find(media => media.type === 'video');
+
+  if (!videoMedia) {
+    return null;
+  }
+
+  return videoMedia.direction;
+};
+export const deactivateVideoModifier = (rawDescription: Record<string, any>): Promise<Record<string, any>> => {
+  const description = rawDescription;
+  description.sdp = toggleVideoDirection(description.sdp, 'inactive');
+  return Promise.resolve(description);
+};
+export const activateVideoModifier = (rawDescription: Record<string, any>): Promise<Record<string, any>> => {
+  const description = rawDescription;
+  description.sdp = toggleVideoDirection(description.sdp, 'sendrecv');
+  return Promise.resolve(description);
+};
+export const hasAnActiveVideo = (sdp: string | null | undefined): boolean => {
+  if (!sdp) {
+    return false;
+  }
+
+  const parsedSdp = sdpParser.parse(sdp);
+  return !!parsedSdp.media.find(media => media.type === 'video' && media.port > 10 && (!media.direction || media.direction !== 'inactive'));
+};
+export const fixSdp = (sdp: string, candidates: Record<string, any>[], forcePort = true): string => {
+  const parsedSdp: any = sdpParser.parse(sdp);
+  const mainCandidate = getSrflxOrRelay(candidates)[0];
+  const ip = mainCandidate ? mainCandidate.ip : null;
+
+  if (ip) {
+    parsedSdp.origin.address = ip;
+  }
+
+  parsedSdp.media = parsedSdp.media.map((media: any) => {
+    const port = forcePort ? mainCandidate ? mainCandidate.port : media.port : media.port;
+    return { ...media,
+      port,
+      candidates: (media.candidates || []).concat(candidates),
+      direction: port < 10 ? 'inactive' : media.direction,
+    };
+  });
+  let fixed = sdpParser.write(parsedSdp);
+
+  if (ip) {
+    fixed = fixed.replace(/IN IP4 0.0.0.0/g, `IN IP4 ${ip}`);
+  }
+
+  return fixed;
+};
+export const addIcesInAllBundles = (sdp: string) => {
+  const parsedSdp = sdpParser.parse(sdp);
+  const mediaWithCandidate = parsedSdp.media.find(media => !!media.candidates);
+
+  if (!mediaWithCandidate) {
+    return sdp;
+  }
+
+  const {
+    candidates,
+  } = mediaWithCandidate;
+  parsedSdp.media = parsedSdp.media.map(media => ({ ...media,
+    candidates: media.candidates || candidates,
+  }));
+  return sdpParser.write(parsedSdp);
+};

package/src/utils/{string.js → string.ts}

@@ -1,8 +1,7 @@
-// @flow
-
-export const camelToUnderscore = (key: string) => {
+export const camelToUnderscore = (key: string): string => {
   if (typeof key !== 'string') {
     throw new Error('Input is not a string');
   }
+
   return key.charAt(0).toLowerCase() + key.substring(1).replace(/([A-Z])/g, '_$1').toLowerCase();
 };

package/src/utils/update-from.ts

@@ -0,0 +1,11 @@
+/* eslint-disable no-param-reassign */
+export default ((instance: any, from: any) => {
+  Object.keys(from)
+    .forEach(key => {
+      if ((!instance[key] && from[key])
+    || (typeof instance[key] !== 'undefined' && typeof from[key] !== 'undefined' && instance[key] !== from[key])
+      ) {
+        instance[key] = from[key];
+      }
+    });
+});

package/src/utils/{webrtc.js → webrtc.ts}

@@ -1,5 +1,19 @@
-export const parseCandidate = line => {
+type Candidate = {
+  foundation: string,
+  component: string,
+  protocol: string,
+  priority: number,
+  ip: string,
+  port: number,
+  type: string,
+  relatedAddress?: string,
+  relatedPort?: number,
+  tcpType?: string
+};
+
+export const parseCandidate = (line: string) => {
   let parts;
+
   // Parse both variants.
   if (line.indexOf('a=candidate:') === 0) {
     parts = line.substring(12).split(' ');
@@ -7,7 +21,7 @@ export const parseCandidate = line => {
     parts = line.substring(10).split(' ');
   }
 
-  const candidate = {
+  const candidate: Candidate = {
     foundation: parts[0],
     component: parts[1],
     protocol: parts[2].toLowerCase(),
@@ -23,13 +37,17 @@ export const parseCandidate = line => {
       case 'raddr':
         candidate.relatedAddress = parts[i + 1];
         break;
+
       case 'rport':
         candidate.relatedPort = parseInt(parts[i + 1], 10);
         break;
+
       case 'tcptype':
         candidate.tcpType = parts[i + 1];
         break;
-      default: // Unknown extensions are silently ignored.
+
+      default:
+        // Unknown extensions are silently ignored.
         break;
     }
   }