Source: lib/util/config_utils.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.util.ConfigUtils');
  9. goog.require('goog.asserts');
  10. goog.require('shaka.log');
  11. goog.require('shaka.util.ArrayUtils');
  12. goog.require('shaka.util.ObjectUtils');
  15. /** @export */
  16. shaka.util.ConfigUtils = class {
  17.   /**
  18.    * @param {!Object} destination
  19.    * @param {!Object} source
  20.    * @param {!Object} template supplies default values
  21.    * @param {!Object} overrides
  22.    *   Supplies override type checking.  When the current path matches
  23.    *   the key in this object, each sub-value must match the type in this
  24.    *   object. If this contains an Object, it is used as the template.
  25.    * @param {string} path to this part of the config
  26.    * @return {boolean}
  27.    * @export
  28.    */
  29.   static mergeConfigObjects(destination, source, template, overrides, path) {
  30.     goog.asserts.assert(destination, 'Destination config must not be null!');
  32.     // If true, override the template.
  33.     const overrideTemplate = path in overrides;
  35.     // If true, treat the source as a generic object to be copied without
  36.     // descending more deeply.
  37.     let genericObject = false;
  38.     if (overrideTemplate) {
  39.       genericObject = template.constructor == Object &&
  40.         Object.keys(overrides).length == 0;
  41.     } else {
  42.       genericObject = template.constructor == Object &&
  43.         Object.keys(template).length == 0;
  44.     }
  46.     // If true, don't validate the keys in the next level.
  47.     const ignoreKeys = overrideTemplate || genericObject;
  49.     let isValid = true;
  51.     for (const k in source) {
  52.       const subPath = path + '.' + k;
  53.       const subTemplate = overrideTemplate ? overrides[path] : template[k];
  55.       // The order of these checks is important.
  56.       if (!ignoreKeys && !(k in template)) {
  57.         shaka.log.alwaysError('Invalid config, unrecognized key ' + subPath);
  58.         isValid = false;
  59.       } else if (source[k] === undefined) {
  60.         // An explicit 'undefined' value causes the key to be deleted from the
  61.         // destination config and replaced with a default from the template if
  62.         // possible.
  63.         if (subTemplate === undefined || ignoreKeys) {
  64.           // There is nothing in the template, so delete.
  65.           delete destination[k];
  66.         } else {
  67.           // There is something in the template, so go back to that.
  68.           destination[k] = shaka.util.ObjectUtils.cloneObject(subTemplate);
  69.         }
  70.       } else if (genericObject) {
  71.         // Copy the fields of a generic object directly without a template and
  72.         // without descending any deeper.
  73.         destination[k] = source[k];
  74.       } else if (subTemplate.constructor == Object &&
  75.                  source[k] &&
  76.                  source[k].constructor == Object) {
  77.         // These are plain Objects with no other constructor.
  79.         if (!destination[k]) {
  80.           // Initialize the destination with the template so that normal
  81.           // merging and type-checking can happen.
  82.           destination[k] = shaka.util.ObjectUtils.cloneObject(subTemplate);
  83.         }
  85.         const subMergeValid = shaka.util.ConfigUtils.mergeConfigObjects(
  86.             destination[k], source[k], subTemplate, overrides, subPath);
  87.         isValid = isValid && subMergeValid;
  88.       } else if (typeof source[k] != typeof subTemplate ||
  89.                  source[k] == null ||
  90.                  // Function constructors are not informative, and differ
  91.                  // between sync and async functions.  So don't look at
  92.                  // constructor for function types.
  93.                  (typeof source[k] != 'function' &&
  94.                   source[k].constructor != subTemplate.constructor)) {
  95.         // The source is the wrong type.  This check allows objects to be
  96.         // nulled, but does not allow null for any non-object fields.
  97.         shaka.log.alwaysError('Invalid config, wrong type for ' + subPath);
  98.         isValid = false;
  99.       } else if (typeof template[k] == 'function' &&
  100.                  template[k].length != source[k].length) {
  101.         shaka.log.alwaysWarn(
  102.             'Unexpected number of arguments for ' + subPath);
  103.         destination[k] = source[k];
  104.       } else if (Array.isArray(destination[k])) {
  105.         // Make a copy of the input array, so that changes to the source object
  106.         // don't immediately affect the running config.
  107.         // Since everything here is very loosely-typed, use a cast to convince
  108.         // the compiler we're not calling slice() on a potential ArrayBuffer,
  109.         // which would break Tizen.
  110.         destination[k] = /** @type {Array} */(source[k]).slice();
  111.       } else {
  112.         destination[k] = source[k];
  113.       }
  114.     }
  116.     return isValid;
  117.   }
  120.   /**
  121.    * Convert config from ('fieldName', value) format to a partial config object.
  122.    *
  123.    * E. g. from ('manifest.retryParameters.maxAttempts', 1) to
  124.    * { manifest: { retryParameters: { maxAttempts: 1 }}}.
  125.    *
  126.    * @param {string} fieldName
  127.    * @param {*} value
  128.    * @return {!Object}
  129.    * @export
  130.    */
  131.   static convertToConfigObject(fieldName, value) {
  132.     const configObject = {};
  133.     let last = configObject;
  134.     let searchIndex = 0;
  135.     let nameStart = 0;
  136.     while (true) {
  137.       const idx = fieldName.indexOf('.', searchIndex);
  138.       if (idx < 0) {
  139.         break;
  140.       }
  141.       if (idx == 0 || fieldName[idx - 1] != '\\') {
  142.         const part = fieldName.substring(nameStart, idx).replace(/\\\./g, '.');
  143.         last[part] = {};
  144.         last = last[part];
  145.         nameStart = idx + 1;
  146.       }
  147.       searchIndex = idx + 1;
  148.     }
  150.     last[fieldName.substring(nameStart).replace(/\\\./g, '.')] = value;
  151.     return configObject;
  152.   }
  154.   /**
  155.    * Reference the input parameters so the compiler doesn't remove them from
  156.    * the calling function.  Return whatever value is specified.
  157.    *
  158.    * This allows an empty or default implementation of a config callback that
  159.    * still bears the complete function signature even in compiled mode.
  160.    *
  161.    * The caller should look something like this:
  162.    *
  163.    *   const callback = (a, b, c, d) => {
  164.    *     return referenceParametersAndReturn(
  165.              [a, b, c, d],
  166.              a);  // Can be anything, doesn't need to be one of the parameters
  167.    *   };
  168.    *
  169.    * @param {!Array<?>} parameters
  170.    * @param {T} returnValue
  171.    * @return {T}
  172.    * @template T
  173.    * @noinline
  174.    */
  175.   static referenceParametersAndReturn(parameters, returnValue) {
  176.     return parameters && returnValue;
  177.   }
  179.   /**
  180.    * @param {!Object} object
  181.    * @param {!Object} base
  182.    * @return {!Object}
  183.    * @export
  184.    */
  185.   static getDifferenceFromConfigObjects(object, base) {
  186.     const isObject = (obj) => {
  187.       return obj && typeof obj === 'object' && !Array.isArray(obj);
  188.     };
  190.     const isArrayEmpty = (array) => {
  191.       return Array.isArray(array) && array.length === 0;
  192.     };
  194.     const changes = (object, base) => {
  195.       return Object.keys(object).reduce((acc, key) => {
  196.         const value = object[key];
  197.         // eslint-disable-next-line no-prototype-builtins
  198.         if (!base.hasOwnProperty(key)) {
  199.           acc[key] = value;
  200.         } else if (value instanceof HTMLElement &&
  201.           base[key] instanceof HTMLElement) {
  202.           if (!value.isEqualNode(base[key])) {
  203.             acc[key] = value;
  204.           }
  205.         } else if (isObject(value) && isObject(base[key])) {
  206.           const diff = changes(value, base[key]);
  207.           if (Object.keys(diff).length > 0 || !isObject(diff)) {
  208.             acc[key] = diff;
  209.           }
  210.         } else if (Array.isArray(value) && Array.isArray(base[key])) {
  211.           if (!shaka.util.ArrayUtils.hasSameElements(value, base[key])) {
  212.             acc[key] = value;
  213.           }
  214.         } else if (Number.isNaN(value) && Number.isNaN(base[key])) {
  215.           // Do nothing if both are NaN
  216.         } else if (value !== base[key]) {
  217.           acc[key] = value;
  218.         }
  219.         return acc;
  220.       }, {});
  221.     };
  223.     const diff = changes(object, base);
  225.     const removeEmpty = (obj) => {
  226.       for (const key of Object.keys(obj)) {
  227.         if (obj[key] instanceof HTMLElement) {
  228.           // Do nothing if it's a HTMLElement
  229.         } else if (isObject(obj[key]) && Object.keys(obj[key]).length === 0) {
  230.           delete obj[key];
  231.         } else if (isArrayEmpty(obj[key])) {
  232.           delete obj[key];
  233.         } else if (typeof obj[key] == 'function') {
  234.           delete obj[key];
  235.         } else if (isObject(obj[key])) {
  236.           removeEmpty(obj[key]);
  237.           if (Object.keys(obj[key]).length === 0) {
  238.             delete obj[key];
  239.           }
  240.         }
  241.       }
  242.     };
  244.     removeEmpty(diff);
  245.     return diff;
  246.   }
  247. };