load.js

/**
 * @license
 * Copyright 2016 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */


function shakaUncompiledModeSupported() {
  // Check if ES6 arrow function syntax and ES7 async are usable.  Both are
  // needed for uncompiled builds to work.
  try {
    eval('async ()=>{}');
    return true;
  } catch (e) {
    return false;
  }
}

/**
 * Loads both library and application sources.  Chooses compiled or debug
 * version of the sources based on the presence or absence of the URL parameter
 * "compiled".  Uses the global arrays COMPILED_JS, COMPILED_DEBUG_JS, and
 * UNCOMPILED_JS, defined by the application in advance.
 *
 * This dynamic loading process is not necessary in a production environment,
 * but simplifies the process of switching between compiled and uncompiled
 * mode during development.
 */
(function() {  // anonymous namespace
  // The URL of the page itself, without URL fragments or search strings.
  var pageUrl = location.href.split('#')[0].split('?')[0];
  // The URL of the page, up to and including the final '/'.
  var baseUrl = pageUrl.split('/').slice(0, -1).join('/') + '/';

  function loadRelativeScript(src) {
    importScript(baseUrl + src);
  }

  // NOTE: This is a quick-and-easy hack based on assumption that the old
  // demo page will be replaced in the near future.
  function loadSpecificCss(href, linkRel) {
    var link = document.createElement('link');
    link.type = 'text/css';
    link.href = baseUrl + href;
    link.rel = linkRel;

    document.head.appendChild(link);
  }
  function loadCss(buildType) {
    // These should override the compiled versions, which have already been
    // hard-coded into the HTML.  This get us the best balance between avoiding
    // a flash of unstyled content and allowing the developer to quickly reload
    // uncompiled LESS in uncompiled mode.
    if (buildType == 'uncompiled') {
      loadSpecificCss('../ui/controls.less', 'stylesheet/less');
      loadSpecificCss('../demo/demo.less', 'stylesheet/less');
    }
  }

  function importScript(src) {
    var script = document.createElement('script');
    script.type = 'text/javascript';
    script.src = src;
    script.defer = true;
    // Setting async = false is important to make sure the script is imported
    // before the 'load' event fires.
    script.async = false;  // eslint-disable-line id-blacklist
    document.head.appendChild(script);
  }

  window.CLOSURE_IMPORT_SCRIPT = importScript;

  var fields = location.search.substr(1);
  fields = fields ? fields.split(';') : [];
  var fragments = location.hash.substr(1);
  fragments = fragments ? fragments.split(';') : [];
  var combined = fields.concat(fragments);

  var buildType = 'uncompiled';
  var buildSpecified = false;

  if (!shakaUncompiledModeSupported()) {
    // If uncompiled mode is not supported, default to the compiled debug
    // version, which should still work.
    buildType = 'debug_compiled';
  }

  if (!navigator.onLine) {
    // If we're offline, default to the compiled version, which may have been
    // cached by the service worker.
    buildType = 'compiled';
  }

  // Very old browsers do not have Array.prototype.indexOf, so we loop.
  for (var i = 0; i < combined.length; ++i) {
    if (combined[i] == 'build=compiled') {
      buildType = 'compiled';
      buildSpecified = true;
      break;
    }
    if (combined[i] == 'build=debug_compiled') {
      buildType = 'debug_compiled';
      buildSpecified = true;
      break;
    }
    if (combined[i] == 'build=uncompiled') {
      buildType = 'uncompiled';
      buildSpecified = true;
      break;
    }
  }

  if (!shakaUncompiledModeSupported() && buildType == 'uncompiled') {
    // The URL says uncompiled, but we know it won't work.  This URL was
    // probably copied from some other browser, but it won't work in this one.
    // Force the use of the compiled debug build and update the hash.
    buildType = 'debug_compiled';

    // Replace the build type in either the hash or the URL parameters.
    // At this point, we don't know precisely which contained the build type.
    location.hash = location.hash.replace(
        'build=uncompiled', 'build=debug_compiled');
    location.href = location.href.replace(
        'build=uncompiled', 'build=debug_compiled');
    // Changing location.href will trigger a refresh of the page.  If the
    // build type was in the URL parameters, the page will now be refreshed.
    // If the build type was in the hash, the page will continue to load with
    // an updated hash and the correct library type.
  }

  // If no build was specified in the URL, update the fragment with the default
  // we chose.
  if (!buildSpecified) {
    if (location.hash.length) {
      location.hash += ';';
    }
    location.hash += 'build=' + buildType;
  }

  loadCss(buildType);

  // The application must define its list of compiled and uncompiled sources
  // before including this loader.  The URLs should be relative to the page.
  var scripts = {
    'compiled': window['COMPILED_JS'],
    'debug_compiled': window['COMPILED_DEBUG_JS'],
    'uncompiled': window['UNCOMPILED_JS'],
  }[buildType];
  for (var j = 0; j < scripts.length; ++j) {
    loadRelativeScript(scripts[j]);
  }
})();  // anonymous namespace