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 {
  105.         destination[k] = source[k];
  106.       }
  107.     }
  109.     return isValid;
  110.   }
  113.   /**
  114.    * Convert config from ('fieldName', value) format to a partial config object.
  115.    *
  116.    * E. g. from ('manifest.retryParameters.maxAttempts', 1) to
  117.    * { manifest: { retryParameters: { maxAttempts: 1 }}}.
  118.    *
  119.    * @param {string} fieldName
  120.    * @param {*} value
  121.    * @return {!Object}
  122.    * @export
  123.    */
  124.   static convertToConfigObject(fieldName, value) {
  125.     const configObject = {};
  126.     let last = configObject;
  127.     let searchIndex = 0;
  128.     let nameStart = 0;
  129.     while (true) {
  130.       const idx = fieldName.indexOf('.', searchIndex);
  131.       if (idx < 0) {
  132.         break;
  133.       }
  134.       if (idx == 0 || fieldName[idx - 1] != '\\') {
  135.         const part = fieldName.substring(nameStart, idx).replace(/\\\./g, '.');
  136.         last[part] = {};
  137.         last = last[part];
  138.         nameStart = idx + 1;
  139.       }
  140.       searchIndex = idx + 1;
  141.     }
  143.     last[fieldName.substring(nameStart).replace(/\\\./g, '.')] = value;
  144.     return configObject;
  145.   }
  147.   /**
  148.    * Reference the input parameters so the compiler doesn't remove them from
  149.    * the calling function.  Return whatever value is specified.
  150.    *
  151.    * This allows an empty or default implementation of a config callback that
  152.    * still bears the complete function signature even in compiled mode.
  153.    *
  154.    * The caller should look something like this:
  155.    *
  156.    *   const callback = (a, b, c, d) => {
  157.    *     return referenceParametersAndReturn(
  158.              [a, b, c, d],
  159.              a);  // Can be anything, doesn't need to be one of the parameters
  160.    *   };
  161.    *
  162.    * @param {!Array<?>} parameters
  163.    * @param {T} returnValue
  164.    * @return {T}
  165.    * @template T
  166.    * @noinline
  167.    */
  168.   static referenceParametersAndReturn(parameters, returnValue) {
  169.     return parameters && returnValue;
  170.   }
  172.   /**
  173.    * @param {!Object} object
  174.    * @param {!Object} base
  175.    * @return {!Object}
  176.    * @export
  177.    */
  178.   static getDifferenceFromConfigObjects(object, base) {
  179.     const isObject = (obj) => {
  180.       return obj && typeof obj === 'object' && !Array.isArray(obj);
  181.     };
  183.     const isArrayEmpty = (array) => {
  184.       return Array.isArray(array) && array.length === 0;
  185.     };
  187.     const changes = (object, base) => {
  188.       return Object.keys(object).reduce((acc, key) => {
  189.         const value = object[key];
  190.         // eslint-disable-next-line no-prototype-builtins
  191.         if (!base.hasOwnProperty(key)) {
  192.           acc[key] = value;
  193.         } else if (value instanceof HTMLElement &&
  194.           base[key] instanceof HTMLElement) {
  195.           if (!value.isEqualNode(base[key])) {
  196.             acc[key] = value;
  197.           }
  198.         } else if (isObject(value) && isObject(base[key])) {
  199.           const diff = changes(value, base[key]);
  200.           if (Object.keys(diff).length > 0 || !isObject(diff)) {
  201.             acc[key] = diff;
  202.           }
  203.         } else if (Array.isArray(value) && Array.isArray(base[key])) {
  204.           if (!shaka.util.ArrayUtils.hasSameElements(value, base[key])) {
  205.             acc[key] = value;
  206.           }
  207.         } else if (Number.isNaN(value) && Number.isNaN(base[key])) {
  208.           // Do nothing if both are NaN
  209.         } else if (value !== base[key]) {
  210.           acc[key] = value;
  211.         }
  212.         return acc;
  213.       }, {});
  214.     };
  216.     const diff = changes(object, base);
  218.     const removeEmpty = (obj) => {
  219.       for (const key of Object.keys(obj)) {
  220.         if (obj[key] instanceof HTMLElement) {
  221.           // Do nothing if it's a HTMLElement
  222.         } else if (isObject(obj[key]) && Object.keys(obj[key]).length === 0) {
  223.           delete obj[key];
  224.         } else if (isArrayEmpty(obj[key])) {
  225.           delete obj[key];
  226.         } else if (typeof obj[key] == 'function') {
  227.           delete obj[key];
  228.         } else if (isObject(obj[key])) {
  229.           removeEmpty(obj[key]);
  230.           if (Object.keys(obj[key]).length === 0) {
  231.             delete obj[key];
  232.           }
  233.         }
  234.       }
  235.     };
  237.     removeEmpty(diff);
  238.     return diff;
  239.   }
  240. };