Adding support for segments in Period and Representation.

package.json

@@ -49,6 +49,7 @@
     "src/"
   ],
   "devDependencies": {
+    "babel-eslint": "^8.2.1",
     "babel-plugin-external-helpers": "^6.22.0",
     "babel-plugin-transform-object-assign": "^6.8.0",
     "babel-preset-es2015": "^6.14.0",

src/inheritAttributes.js

@@ -1,5 +1,5 @@
 import { flatten } from './utils/list';
-import { shallowMerge, getAttributes } from './utils/object';
+import { getAttributes, merge } from './utils/object';
 import { parseDuration } from './utils/time';
 import { findChildren, getContent } from './utils/xml';
 import resolveUrl from './utils/resolveUrl';
@@ -52,7 +52,7 @@ export const getSegmentInformation = (adaptationSet) => {
   const segmentTemplate = findChildren(adaptationSet, 'SegmentTemplate')[0];
   const segmentList = findChildren(adaptationSet, 'SegmentList')[0];
   const segmentUrls = segmentList && findChildren(segmentList, 'SegmentURL')
-    .map(s => shallowMerge({ tag: 'SegmentURL' }, getAttributes(s)));
+    .map(s => merge({ tag: 'SegmentURL' }, getAttributes(s)));
   const segmentBase = findChildren(adaptationSet, 'SegmentBase')[0];
   const segmentTimelineParentNode = segmentList || segmentTemplate;
   const segmentTimeline = segmentTimelineParentNode &&
@@ -78,21 +78,29 @@ export const getSegmentInformation = (adaptationSet) => {
     template.initialization = { sourceURL: template.initialization };
   }
 
-  return {
+  const segmentInfo = {
     template,
     timeline: segmentTimeline &&
       findChildren(segmentTimeline, 'S').map(s => getAttributes(s)),
-    list: segmentList && shallowMerge(
+    list: segmentList && merge(
       getAttributes(segmentList),
       {
         segmentUrls,
         initialization: getAttributes(segmentInitialization)
       }),
-    base: segmentBase && shallowMerge(
+    base: segmentBase && merge(
       getAttributes(segmentBase), {
         initialization: getAttributes(segmentInitialization)
       })
   };
+
+  Object.keys(segmentInfo).forEach(key => {
+    if (!segmentInfo[key]) {
+      delete segmentInfo[key];
+    }
+  });
+
+  return segmentInfo;
 };
 
 /**
@@ -131,15 +139,16 @@ export const getSegmentInformation = (adaptationSet) => {
  *         Callback map function
  */
 export const inheritBaseUrls =
-(adaptationSetAttributes, adaptationSetBaseUrls, segmentInfo) => (representation) => {
+(adaptationSetAttributes, adaptationSetBaseUrls, adaptationSetSegmentInfo) => (representation) => {
   const repBaseUrlElements = findChildren(representation, 'BaseURL');
   const repBaseUrls = buildBaseUrls(adaptationSetBaseUrls, repBaseUrlElements);
-  const attributes = shallowMerge(adaptationSetAttributes, getAttributes(representation));
+  const attributes = merge(adaptationSetAttributes, getAttributes(representation));
+  const representationSegmentInfo = getSegmentInformation(representation);
 
   return repBaseUrls.map(baseUrl => {
     return {
-      segmentInfo,
-      attributes: shallowMerge(attributes, { baseUrl })
+      segmentInfo: merge(adaptationSetSegmentInfo, representationSegmentInfo),
+      attributes: merge(attributes, { baseUrl })
     };
   });
 };
@@ -167,20 +176,21 @@ export const inheritBaseUrls =
  *         Callback map function
  */
 export const toRepresentations =
-(periodAttributes, periodBaseUrls) => (adaptationSet) => {
+(periodAttributes, periodBaseUrls, periodSegmentInfo) => (adaptationSet) => {
   const adaptationSetAttributes = getAttributes(adaptationSet);
   const adaptationSetBaseUrls = buildBaseUrls(periodBaseUrls,
                                               findChildren(adaptationSet, 'BaseURL'));
   const role = findChildren(adaptationSet, 'Role')[0];
   const roleAttributes = { role: getAttributes(role) };
-  const attrs = shallowMerge(periodAttributes,
+  const attrs = merge(periodAttributes,
                              adaptationSetAttributes,
                              roleAttributes);
   const segmentInfo = getSegmentInformation(adaptationSet);
   const representations = findChildren(adaptationSet, 'Representation');
+  const adaptationSetSegmentInfo = merge(periodSegmentInfo, segmentInfo);
 
   return flatten(
-    representations.map(inheritBaseUrls(attrs, adaptationSetBaseUrls, segmentInfo)));
+    representations.map(inheritBaseUrls(attrs, adaptationSetBaseUrls, adaptationSetSegmentInfo)));
 };
 
 /**
@@ -210,10 +220,12 @@ export const toRepresentations =
  */
 export const toAdaptationSets = (mpdAttributes, mpdBaseUrls) => (period, periodIndex) => {
   const periodBaseUrls = buildBaseUrls(mpdBaseUrls, findChildren(period, 'BaseURL'));
-  const periodAttributes = shallowMerge({ periodIndex }, mpdAttributes);
+  const periodAtt = getAttributes(period);
+  const periodAttributes = merge(mpdAttributes, periodAtt, { periodIndex });
   const adaptationSets = findChildren(period, 'AdaptationSet');
+  const periodSegmentInfo = getSegmentInformation(period);
 
-  return flatten(adaptationSets.map(toRepresentations(periodAttributes, periodBaseUrls)));
+  return flatten(adaptationSets.map(toRepresentations(periodAttributes, periodBaseUrls, periodSegmentInfo)));
 };
 
 /**
@@ -243,4 +255,3 @@ export const inheritAttributes = (mpd, manifestUri = '') => {
 
   return flatten(periods.map(toAdaptationSets(mpdAttributes, mpdBaseUrls)));
 };
-

src/toPlaylists.js

@@ -1,28 +1,26 @@
-import { shallowMerge } from './utils/object';
+import { merge } from './utils/object';
 import { segmentsFromTemplate } from './segment/segmentTemplate';
 import { segmentsFromList } from './segment/segmentList';
 import { segmentsFromBase } from './segment/segmentBase';
 
 export const generateSegments = (segmentInfo, attributes) => {
   if (segmentInfo.template) {
     return segmentsFromTemplate(
-      shallowMerge(segmentInfo.template, attributes),
+      merge(attributes, segmentInfo.template),
       segmentInfo.timeline
     );
   }
-
   if (segmentInfo.base) {
-    return segmentsFromBase(shallowMerge(segmentInfo.base, attributes));
+    return segmentsFromBase(merge(attributes, segmentInfo.base));
   }
-
   if (segmentInfo.list) {
     return segmentsFromList(
-      shallowMerge(segmentInfo.list, attributes), segmentInfo.timeline
+      merge(attributes, segmentInfo.list), segmentInfo.timeline
     );
   }
 };
 
-export const toPlaylists = representations => {
+export const toPlaylists = (representations) => {
   return representations.map(({ attributes, segmentInfo }) => {
     const segments = generateSegments(segmentInfo, attributes);