webfontloader 1.4.0 → 1.4.1

data/src/core/initialize.js

@@ -4,16 +4,6 @@ goog.require('webfont.UserAgentParser');
 goog.require('webfont.FontModuleLoader');
 goog.require('webfont.WebFont');
 
-/**
- * @typedef {Array.<string>}
- */
-webfont.FontFamilies;
-
-/**
- * @typedef {Object.<string, Array.<string>>}
- */
-webfont.FontVariations;
-
 /**
  * @typedef {Object.<string, Array.<string>>}
  */

data/src/core/webfont.js

@@ -0,0 +1,134 @@
+goog.provide('webfont.WebFont');
+
+goog.require('webfont.DomHelper');
+goog.require('webfont.EventDispatcher');
+goog.require('webfont.FontWatcher');
+
+/**
+ * @param {Window} mainWindow The main application window containing
+ *   webfontloader.js.
+ * @param {webfont.FontModuleLoader} fontModuleLoader A loader instance to use.
+ * @param {webfont.UserAgent} userAgent The detected user agent to load for.
+ * @constructor
+ */
+webfont.WebFont = function(mainWindow, fontModuleLoader, userAgent) {
+  this.mainWindow_ = mainWindow;
+  this.fontModuleLoader_ = fontModuleLoader;
+  this.userAgent_ = userAgent;
+  this.moduleLoading_ = 0;
+  this.moduleFailedLoading_ = 0;
+};
+
+goog.scope(function () {
+  var WebFont = webfont.WebFont,
+      DomHelper = webfont.DomHelper,
+      EventDispatcher = webfont.EventDispatcher,
+      FontWatcher = webfont.FontWatcher;
+
+  /**
+   * @param {string} name
+   * @param {webfont.FontModuleFactory} factory
+   */
+  WebFont.prototype.addModule = function(name, factory) {
+    this.fontModuleLoader_.addModuleFactory(name, factory);
+  };
+
+  /**
+   * @param {Object} configuration
+   */
+  WebFont.prototype.load = function(configuration) {
+    var context = configuration['context'] || this.mainWindow_;
+    this.domHelper_ = new DomHelper(this.mainWindow_, context);
+
+    var eventDispatcher = new EventDispatcher(
+        this.domHelper_, context.document.documentElement, configuration);
+
+    if (this.userAgent_.getBrowserInfo().hasWebFontSupport()) {
+      this.load_(eventDispatcher, configuration);
+    } else {
+      eventDispatcher.dispatchInactive();
+    }
+  };
+
+  /**
+   * @param {webfont.FontModule} module
+   * @param {webfont.EventDispatcher} eventDispatcher
+   * @param {webfont.FontWatcher} fontWatcher
+   * @param {boolean} support
+   */
+  WebFont.prototype.isModuleSupportingUserAgent_ = function(module, eventDispatcher,
+      fontWatcher, support) {
+    var fontWatchRunnerCtor = module.getFontWatchRunnerCtor ?
+        module.getFontWatchRunnerCtor() : webfont.FontWatchRunner,
+        that = this;
+
+    if (!support) {
+      var allModulesLoaded = --this.moduleLoading_ == 0;
+
+      this.moduleFailedLoading_--;
+      if (allModulesLoaded) {
+        if (this.moduleFailedLoading_ == 0) {
+          eventDispatcher.dispatchInactive();
+        } else {
+          eventDispatcher.dispatchLoading();
+        }
+      }
+      fontWatcher.watch([], {}, fontWatchRunnerCtor, allModulesLoaded);
+      return;
+    }
+
+    module.load(function (fonts) {
+      that.onModuleReady_(eventDispatcher, fontWatcher, fontWatchRunnerCtor, fonts);
+    });
+  };
+
+  /**
+   * @param {webfont.EventDispatcher} eventDispatcher
+   * @param {webfont.FontWatcher} fontWatcher
+   * @param {function(new:webfont.FontWatchRunner,
+   *                  function(webfont.Font),
+   *                  function(webfont.Font),
+   *                  webfont.DomHelper,
+   *                  webfont.Font,
+   *                  webfont.BrowserInfo,
+   *                  number=,
+   *                  Object.<string, boolean>=,
+   *                  string=)} fontWatchRunnerCtor
+   * @param {Array.<webfont.Font>} fonts
+   * @param {webfont.FontTestStrings=} opt_fontTestStrings
+   */
+  WebFont.prototype.onModuleReady_ = function(eventDispatcher, fontWatcher,
+      fontWatchRunnerCtor, fonts, opt_fontTestStrings) {
+    var allModulesLoaded = --this.moduleLoading_ == 0;
+
+    if (allModulesLoaded) {
+      eventDispatcher.dispatchLoading();
+    }
+
+    setTimeout(function () {
+      fontWatcher.watch(fonts, opt_fontTestStrings || {}, fontWatchRunnerCtor, allModulesLoaded);
+    }, 0);
+  };
+
+  /**
+   * @param {webfont.EventDispatcher} eventDispatcher
+   * @param {Object} configuration
+   */
+  WebFont.prototype.load_ = function(eventDispatcher, configuration) {
+    var modules = this.fontModuleLoader_.getModules(configuration, this.domHelper_),
+        timeout = configuration['timeout'],
+        self = this;
+
+    this.moduleFailedLoading_ = this.moduleLoading_ = modules.length;
+
+    var fontWatcher = new webfont.FontWatcher(this.userAgent_, this.domHelper_, eventDispatcher, timeout);
+
+    for (var i = 0, len = modules.length; i < len; i++) {
+      var module = modules[i];
+
+      module.supportUserAgent(this.userAgent_,
+          goog.bind(this.isModuleSupportingUserAgent_, this, module,
+          eventDispatcher, fontWatcher));
+    }
+  };
+});

data/src/custom/customcss.js

@@ -1,5 +1,7 @@
 goog.provide('webfont.CustomCss');
 
+goog.require('webfont.Font');
+
 /**
  *
  * WebFont.load({
@@ -19,7 +21,8 @@ webfont.CustomCss = function(domHelper, configuration) {
 webfont.CustomCss.NAME = 'custom';
 
 goog.scope(function () {
-  var CustomCss = webfont.CustomCss;
+  var CustomCss = webfont.CustomCss,
+      Font = webfont.Font;
 
   CustomCss.prototype.load = function(onReady) {
     var i, len;
@@ -32,22 +35,23 @@ goog.scope(function () {
       this.domHelper_.insertInto('head', this.domHelper_.createCssLink(url));
     }
 
-    var families = [];
-    var variations = {};
+    var fonts = [];
+
     for (i = 0, len = familiesConfiguration.length; i < len; i++) {
       var components = familiesConfiguration[i].split(":");
-      var family = components[0];
-      var familyVariations = components[1];
 
-      families.push(family);
+      if (components[1]) {
+        var variations = components[1].split(",");
 
-      if (familyVariations) {
-        var newVariations = familyVariations.split(",");
-        variations[family] = (variations[family] || []).concat(newVariations);
+        for (var j = 0; j < variations.length; j += 1) {
+          fonts.push(new Font(components[0], variations[j]));
+        }
+      } else {
+        fonts.push(new Font(components[0]));
       }
     }
 
-    onReady(families, variations);
+    onReady(fonts);
   };
 
   CustomCss.prototype.supportUserAgent = function(userAgent, support) {

data/src/fontdeck/fontdeck_script.js

@@ -1,6 +1,6 @@
 goog.provide('webfont.FontdeckScript');
 
-goog.require('webfont.FontVariationDescription');
+goog.require('webfont.Font');
 
 /**
  * @constructor
@@ -9,9 +9,7 @@ goog.require('webfont.FontVariationDescription');
 webfont.FontdeckScript = function(domHelper, configuration) {
   this.domHelper_ = domHelper;
   this.configuration_ = configuration;
-  this.fontFamilies_ = [];
-  this.fontVariations_ = {};
-  this.fvd_ = new webfont.FontVariationDescription();
+  this.fonts_ = [];
 };
 
 webfont.FontdeckScript.NAME = 'fontdeck';
@@ -19,7 +17,9 @@ webfont.FontdeckScript.HOOK = '__webfontfontdeckmodule__';
 webfont.FontdeckScript.API = '//f.fontdeck.com/s/css/js/';
 
 goog.scope(function () {
-  var FontdeckScript = webfont.FontdeckScript;
+  var FontdeckScript = webfont.FontdeckScript,
+      Font = webfont.Font,
+      FontVariationDescription = webfont.FontVariationDescription;
 
   FontdeckScript.prototype.getScriptSrc = function(projectId) {
     var protocol = this.domHelper_.getProtocol();
@@ -46,9 +46,7 @@ goog.scope(function () {
       loadWindow[webfont.FontdeckScript.HOOK][projectId] = function(fontdeckSupports, data) {
         for (var i = 0, j = data['fonts'].length; i<j; ++i) {
           var font = data['fonts'][i];
-          // Add the FVDs
-          self.fontFamilies_.push(font['name']);
-          self.fontVariations_[font['name']] = [self.fvd_.compact("font-weight:" + font['weight'] + ";font-style:" + font['style'])];
+          self.fonts_.push(new Font(font['name'], Font.parseCssVariation('font-weight:' + font['weight'] + ';font-style:' + font['style'])));
         }
         support(fontdeckSupports);
       };
@@ -63,7 +61,7 @@ goog.scope(function () {
   };
 
   FontdeckScript.prototype.load = function(onReady) {
-    onReady(this.fontFamilies_, this.fontVariations_);
+    onReady(this.fonts_);
   };
 });
 

data/src/google/fontapiparser.js

@@ -1,16 +1,14 @@
 goog.provide('webfont.FontApiParser');
 
-goog.require('webfont.FontVariationDescription');
+goog.require('webfont.Font');
 
 /**
  * @constructor
  */
 webfont.FontApiParser = function(fontFamilies) {
   this.fontFamilies_ = fontFamilies;
-  this.parsedFontFamilies_ = [];
-  this.variations_ = {};
+  this.parsedFonts_ = [];
   this.fontTestStrings_ = {};
-  this.fvd_ = new webfont.FontVariationDescription();
 };
 
 
@@ -61,7 +59,8 @@ webfont.FontApiParser.VARIATION_MATCH =
         "|normal|italic)?$");
 
 goog.scope(function () {
-  var FontApiParser = webfont.FontApiParser;
+  var FontApiParser = webfont.FontApiParser,
+      Font = webfont.Font;
 
   FontApiParser.prototype.parse = function() {
     var length = this.fontFamilies_.length;
@@ -96,8 +95,10 @@ goog.scope(function () {
           this.fontTestStrings_[fontFamily] = hanumanTestString;
         }
       }
-      this.parsedFontFamilies_.push(fontFamily);
-      this.variations_[fontFamily] = variations;
+
+      for (var j = 0; j < variations.length; j += 1) {
+        this.parsedFonts_.push(new Font(fontFamily, variations[j]));
+      }
     }
   };
 
@@ -112,8 +113,7 @@ goog.scope(function () {
     }
     var styleMatch = this.normalizeStyle_(groups[2]);
     var weightMatch = this.normalizeWeight_(groups[1]);
-    var css = this.fvd_.expand([styleMatch, weightMatch].join(''));
-    return css ? this.fvd_.compact(css) : null;
+    return [styleMatch, weightMatch].join('');
   };
 
 
@@ -171,12 +171,8 @@ goog.scope(function () {
   };
 
 
-  FontApiParser.prototype.getFontFamilies = function() {
-    return this.parsedFontFamilies_;
-  };
-
-  FontApiParser.prototype.getVariations = function() {
-    return this.variations_;
+  FontApiParser.prototype.getFonts = function() {
+    return this.parsedFonts_;
   };
 
   FontApiParser.prototype.getFontTestStrings = function() {

data/src/google/googlefontapi.js

@@ -59,8 +59,7 @@ goog.scope(function () {
 
     domHelper.insertInto('head', domHelper.createCssLink(
         fontApiUrlBuilder.build()));
-    onReady(fontApiParser.getFontFamilies(), fontApiParser.getVariations(),
-        fontApiParser.getFontTestStrings());
+    onReady(fontApiParser.getFonts(), fontApiParser.getFontTestStrings());
   };
 });
 

data/src/google/lastresortwebkitfontwatchrunner.js

@@ -1,14 +1,14 @@
 goog.provide('webfont.LastResortWebKitFontWatchRunner');
 
+goog.require('webfont.Font');
 goog.require('webfont.FontRuler');
 
 /**
  * @constructor
- * @param {function(string, string)} activeCallback
- * @param {function(string, string)} inactiveCallback
+ * @param {function(webfont.Font)} activeCallback
+ * @param {function(webfont.Font)} inactiveCallback
  * @param {webfont.DomHelper} domHelper
- * @param {string} fontFamily
- * @param {string} fontDescription
+ * @param {webfont.Font} font
  * @param {webfont.BrowserInfo} browserInfo
  * @param {number=} opt_timeout
  * @param {Object.<string, boolean>=} opt_metricCompatibleFonts
@@ -16,11 +16,11 @@ goog.require('webfont.FontRuler');
  * @extends webfont.FontWatchRunner
  */
 webfont.LastResortWebKitFontWatchRunner = function(activeCallback,
-    inactiveCallback, domHelper, fontFamily,
-    fontDescription, browserInfo, opt_timeout, opt_metricCompatibleFonts, opt_fontTestString) {
+    inactiveCallback, domHelper, font,
+    browserInfo, opt_timeout, opt_metricCompatibleFonts, opt_fontTestString) {
 
   goog.base(this, activeCallback, inactiveCallback, domHelper,
-            fontFamily, fontDescription, browserInfo, opt_timeout, opt_metricCompatibleFonts, opt_fontTestString);
+            font, browserInfo, opt_timeout, opt_metricCompatibleFonts, opt_fontTestString);
 
   this.webKitLastResortFontWidths_ = this.setUpWebKitLastResortFontWidths_();
   this.webKitLastResortWidthChange_ = false;
@@ -38,6 +38,7 @@ webfont.LastResortWebKitFontWatchRunner.METRICS_COMPATIBLE_FONTS = {
 
 goog.scope(function () {
   var LastResortWebKitFontWatchRunner = webfont.LastResortWebKitFontWatchRunner,
+      Font = webfont.Font,
       FontRuler = webfont.FontRuler;
 
   /**
@@ -51,23 +52,24 @@ goog.scope(function () {
   LastResortWebKitFontWatchRunner.prototype
       .setUpWebKitLastResortFontWidths_ = function() {
     var lastResortFonts = ['Times New Roman', 'Arial', 'Times', 'Sans', 'Serif'];
+    var variation = this.font_.getVariation();
     var lastResortFontWidths = lastResortFonts.length;
     var webKitLastResortFontWidths = {};
     var fontRuler = new FontRuler(this.domHelper_, this.fontTestString_);
 
     fontRuler.insert();
-    fontRuler.setFont(lastResortFonts[0], this.fontDescription_);
+    fontRuler.setFont(new Font(lastResortFonts[0], variation));
 
     webKitLastResortFontWidths[fontRuler.getWidth()] = true;
     for (var i = 1; i < lastResortFontWidths; i++) {
       var font = lastResortFonts[i];
-      fontRuler.setFont(font, this.fontDescription_);
+      fontRuler.setFont(new Font(font, variation));
       webKitLastResortFontWidths[fontRuler.getWidth()] = true;
 
       // Another WebKit quirk if the normal weight/style is loaded first,
       // the size of the normal weight is returned when loading another weight.
-      if (this.fontDescription_[1] != '4') {
-        fontRuler.setFont(font, this.fontDescription_[0] + '4');
+      if (variation.toString().charAt(1) != '4') {
+        fontRuler.setFont(new Font(font, variation.charAt(0) + '4'));
         webKitLastResortFontWidths[fontRuler.getWidth()] = true;
       }
     }
@@ -92,7 +94,7 @@ goog.scope(function () {
         (!this.webKitLastResortFontWidths_[widthA] &&
          !this.webKitLastResortFontWidths_[widthB])) {
       this.finish_(this.activeCallback_);
-    } else if (goog.now() - this.started_ >= 5000) {
+    } else if (this.hasTimedOut_()) {
 
       // In order to handle the fact that a font could be the same size as the
       // default browser font on a webkit browser, mark the font as active
@@ -101,7 +103,7 @@ goog.scope(function () {
       if (this.webKitLastResortFontWidths_[widthA]
           && this.webKitLastResortFontWidths_[widthB] &&
           LastResortWebKitFontWatchRunner.METRICS_COMPATIBLE_FONTS[
-            this.fontFamily_]) {
+            this.font_.getName()]) {
         this.finish_(this.activeCallback_);
       } else {
         this.finish_(this.inactiveCallback_);

data/src/modules.yml

@@ -5,14 +5,13 @@ core:
   - core/useragent.js
   - core/useragentparser.js
   - core/cssclassname.js
-  - core/cssfontfamilyname.js
-  - core/fontvariationdescription.js
+  - core/font.js
   - core/eventdispatcher.js
   - core/fontmoduleloader.js
   - core/fontruler.js
   - core/fontwatchrunner.js
   - core/fontwatcher.js
-  - core/font.js
+  - core/webfont.js
   - core/initialize.js
 
 ascender:

data/src/monotype/monotype_script.js

@@ -1,5 +1,7 @@
 goog.provide('webfont.MonotypeScript');
 
+goog.require('webfont.Font');
+
 /**
 webfont.load({
 monotype: {
@@ -16,8 +18,7 @@ webfont.MonotypeScript = function (userAgent, domHelper, configuration) {
   this.userAgent_ = userAgent;
   this.domHelper_ = domHelper;
   this.configuration_ = configuration;
-  this.fontFamilies_ = [];
-  this.fontVariations_ = {};
+  this.fonts_ = [];
 };
 
 /**
@@ -40,7 +41,8 @@ webfont.MonotypeScript.HOOK = '__mti_fntLst';
 webfont.MonotypeScript.SCRIPTID = '__MonotypeAPIScript__';
 
 goog.scope(function () {
-  var MonotypeScript = webfont.MonotypeScript;
+  var MonotypeScript = webfont.MonotypeScript,
+      Font = webfont.Font;
 
   MonotypeScript.prototype.supportUserAgent = function (userAgent, support) {
     var self = this;
@@ -55,10 +57,9 @@ goog.scope(function () {
       function onload() {
         if (loadWindow[MonotypeScript.HOOK + projectId]) {
           var mti_fnts = loadWindow[webfont.MonotypeScript.HOOK + projectId]();
-          if (mti_fnts && mti_fnts.length) {
-            var i;
-            for (i = 0; i < mti_fnts.length; i++) {
-              self.fontFamilies_.push(mti_fnts[i]["fontfamily"]);
+          if (mti_fnts) {
+            for (var i = 0; i < mti_fnts.length; i++) {
+              self.fonts_.push(new Font(mti_fnts[i]["fontfamily"]));
             }
           }
         }
@@ -90,7 +91,7 @@ goog.scope(function () {
   };
 
   MonotypeScript.prototype.load = function (onReady) {
-    onReady(this.fontFamilies_, this.fontVariations_);
+    onReady(this.fonts_);
   };
 });