webfontloader 1.3.0 → 1.3.1

data/src/google/googlefontapi.js

@@ -1,5 +1,13 @@
+goog.provide('webfont.GoogleFontApi');
+
+goog.require('webfont.FontApiUrlBuilder');
+goog.require('webfont.FontApiParser');
+goog.require('webfont.FontWatchRunner');
+goog.require('webfont.LastResortWebKitFontWatchRunner');
+
 /**
  * @constructor
+ * @implements {webfont.FontModule}
  */
 webfont.GoogleFontApi = function(userAgent, domHelper, configuration) {
   this.userAgent_ = userAgent;
@@ -9,44 +17,52 @@ webfont.GoogleFontApi = function(userAgent, domHelper, configuration) {
 
 webfont.GoogleFontApi.NAME = 'google';
 
-webfont.GoogleFontApi.prototype.supportUserAgent = function(userAgent, support) {
-  support(userAgent.getBrowserInfo().hasWebFontSupport());
-};
+goog.scope(function () {
+  var GoogleFontApi = webfont.GoogleFontApi,
+      FontWatchRunner = webfont.FontWatchRunner,
+      LastResortWebKitFontWatchRunner = webfont.LastResortWebKitFontWatchRunner,
+      FontApiUrlBuilder = webfont.FontApiUrlBuilder,
+      FontApiParser = webfont.FontApiParser;
 
-webfont.GoogleFontApi.prototype.getFontWatchRunnerCtor = function() {
-  if (this.userAgent_.getEngine() == "AppleWebKit") {
-    return webfont.LastResortWebKitFontWatchRunner;
-  }
-  return webfont.FontWatchRunner;
-};
+  GoogleFontApi.prototype.supportUserAgent = function(userAgent, support) {
+    support(userAgent.getBrowserInfo().hasWebFontSupport());
+  };
 
-webfont.GoogleFontApi.prototype.load = function(onReady) {
-  var domHelper = this.domHelper_;
-  var nonBlockingIe = this.userAgent_.getName() == 'MSIE' &&
-      this.configuration_['blocking'] != true;
+  GoogleFontApi.prototype.getFontWatchRunnerCtor = function() {
+    if (this.userAgent_.getEngine() == "AppleWebKit") {
+      return LastResortWebKitFontWatchRunner;
+    }
+    return FontWatchRunner;
+  };
 
-  if (nonBlockingIe) {
-    domHelper.whenBodyExists(webfont.bind(this, this.insertLink_, onReady));
-  } else {
-    this.insertLink_(onReady);
-  }
-};
+  GoogleFontApi.prototype.load = function(onReady) {
+    var domHelper = this.domHelper_;
+    var nonBlockingIe = this.userAgent_.getName() == 'MSIE' &&
+        this.configuration_['blocking'] != true;
 
-webfont.GoogleFontApi.prototype.insertLink_ = function(onReady) {
-  var domHelper = this.domHelper_;
-  var fontApiUrlBuilder = new webfont.FontApiUrlBuilder(
-      this.configuration_['api'], domHelper.getProtocol(), this.configuration_['text']);
-  var fontFamilies = this.configuration_['families'];
-  fontApiUrlBuilder.setFontFamilies(fontFamilies);
+    if (nonBlockingIe) {
+      domHelper.whenBodyExists(goog.bind(this.insertLink_, this, onReady));
+    } else {
+      this.insertLink_(onReady);
+    }
+  };
 
-  var fontApiParser = new webfont.FontApiParser(fontFamilies);
-  fontApiParser.parse();
+  GoogleFontApi.prototype.insertLink_ = function(onReady) {
+    var domHelper = this.domHelper_;
+    var fontApiUrlBuilder = new FontApiUrlBuilder(
+        this.configuration_['api'], domHelper.getProtocol(), this.configuration_['text']);
+    var fontFamilies = this.configuration_['families'];
+    fontApiUrlBuilder.setFontFamilies(fontFamilies);
 
-  domHelper.insertInto('head', domHelper.createCssLink(
-      fontApiUrlBuilder.build()));
-  onReady(fontApiParser.getFontFamilies(), fontApiParser.getVariations(),
-      fontApiParser.getFontTestStrings());
-};
+    var fontApiParser = new FontApiParser(fontFamilies);
+    fontApiParser.parse();
+
+    domHelper.insertInto('head', domHelper.createCssLink(
+        fontApiUrlBuilder.build()));
+    onReady(fontApiParser.getFontFamilies(), fontApiParser.getVariations(),
+        fontApiParser.getFontTestStrings());
+  };
+});
 
 globalNamespaceObject.addModule(webfont.GoogleFontApi.NAME, function(configuration, domHelper) {
   var userAgentParser = new webfont.UserAgentParser(navigator.userAgent, document);

data/src/google/lastresortwebkitfontwatchrunner.js

@@ -1,29 +1,34 @@
+goog.provide('webfont.LastResortWebKitFontWatchRunner');
+
+goog.require('webfont.FontRuler');
+
 /**
  * @constructor
  * @param {function(string, string)} activeCallback
  * @param {function(string, string)} inactiveCallback
  * @param {webfont.DomHelper} domHelper
- * @param {Object.<string, function(Object): webfont.Size>} fontSizer
- * @param {function(function(), number=)} asyncCall
- * @param {function(): number} getTime
  * @param {string} fontFamily
  * @param {string} fontDescription
- * @param {boolean} hasWebkitFallbackBug
+ * @param {webfont.BrowserInfo} browserInfo
+ * @param {number=} opt_timeout
+ * @param {Object.<string, boolean>=} opt_metricCompatibleFonts
  * @param {string=} opt_fontTestString
  * @extends webfont.FontWatchRunner
  */
 webfont.LastResortWebKitFontWatchRunner = function(activeCallback,
-    inactiveCallback, domHelper, fontSizer, asyncCall, getTime, fontFamily,
-    fontDescription, hasWebkitFallbackBug, opt_fontTestString) {
-  webfont.LastResortWebKitFontWatchRunner.superCtor_.call(this,
-      activeCallback, inactiveCallback, domHelper, fontSizer, asyncCall,
-      getTime, fontFamily, fontDescription, hasWebkitFallbackBug, opt_fontTestString);
+    inactiveCallback, domHelper, fontFamily,
+    fontDescription, browserInfo, opt_timeout, opt_metricCompatibleFonts, opt_fontTestString) {
+
+  goog.base(this, activeCallback, inactiveCallback, domHelper,
+            fontFamily, fontDescription, browserInfo, opt_timeout, opt_metricCompatibleFonts, opt_fontTestString);
+
   this.webKitLastResortFontSizes_ = this.setUpWebKitLastResortFontSizes_();
   this.webKitLastResortSizeChange_ = false;
   this.lastObservedSizeA_ = this.lastResortSizes_[webfont.FontWatchRunner.LastResortFonts.SERIF];
   this.lastObservedSizeB_ = this.lastResortSizes_[webfont.FontWatchRunner.LastResortFonts.SANS_SERIF];;
 };
-webfont.extendsClass(webfont.FontWatchRunner, webfont.LastResortWebKitFontWatchRunner);
+
+goog.inherits(webfont.LastResortWebKitFontWatchRunner, webfont.FontWatchRunner)
 
 webfont.LastResortWebKitFontWatchRunner.METRICS_COMPATIBLE_FONTS = {
     "Arimo": true,
@@ -31,70 +36,78 @@ webfont.LastResortWebKitFontWatchRunner.METRICS_COMPATIBLE_FONTS = {
     "Tinos": true
 };
 
-/**
- * While loading a web font webkit applies a last resort fallback font to the
- * element on which the web font is applied.
- * See file: WebKit/Source/WebCore/css/CSSFontFaceSource.cpp.
- * Looking at the different implementation for the different platforms,
- * the last resort fallback font is different. This code uses the default
- * OS/browsers values.
- */
-webfont.LastResortWebKitFontWatchRunner.prototype
-    .setUpWebKitLastResortFontSizes_ = function() {
-  var lastResortFonts = ['Times New Roman', 'Arial', 'Times', 'Sans', 'Serif'];
-  var lastResortFontSizes = lastResortFonts.length;
-  var webKitLastResortFontSizes = {};
-  var fontRuler = new webfont.FontRuler(this.domHelper_, this.fontSizer_, this.fontTestString_);
+goog.scope(function () {
+  var LastResortWebKitFontWatchRunner = webfont.LastResortWebKitFontWatchRunner,
+      FontRuler = webfont.FontRuler;
 
-  fontRuler.insert();
-  fontRuler.setFont(lastResortFonts[0], this.fontDescription_);
+  /**
+   * While loading a web font webkit applies a last resort fallback font to the
+   * element on which the web font is applied.
+   * See file: WebKit/Source/WebCore/css/CSSFontFaceSource.cpp.
+   * Looking at the different implementation for the different platforms,
+   * the last resort fallback font is different. This code uses the default
+   * OS/browsers values.
+   */
+  LastResortWebKitFontWatchRunner.prototype
+      .setUpWebKitLastResortFontSizes_ = function() {
+    var lastResortFonts = ['Times New Roman', 'Arial', 'Times', 'Sans', 'Serif'];
+    var lastResortFontSizes = lastResortFonts.length;
+    var webKitLastResortFontSizes = {};
+    var fontRuler = new FontRuler(this.domHelper_, this.fontTestString_);
 
-  webKitLastResortFontSizes[fontRuler.getSize().width] = true;
-  for (var i = 1; i < lastResortFontSizes; i++) {
-    var font = lastResortFonts[i];
-    fontRuler.setFont(font, this.fontDescription_);
-    webKitLastResortFontSizes[fontRuler.getSize().width] = true;
+    fontRuler.insert();
+    fontRuler.setFont(lastResortFonts[0], this.fontDescription_);
 
-    // 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');
+    webKitLastResortFontSizes[fontRuler.getSize().width] = true;
+    for (var i = 1; i < lastResortFontSizes; i++) {
+      var font = lastResortFonts[i];
+      fontRuler.setFont(font, this.fontDescription_);
       webKitLastResortFontSizes[fontRuler.getSize().width] = true;
-    }
-  }
-  fontRuler.remove();
-  return webKitLastResortFontSizes;
-};
 
-webfont.LastResortWebKitFontWatchRunner.prototype.check_ = function() {
-  var sizeA = this.fontRulerA_.getSize();
-  var sizeB = this.fontRulerB_.getSize();
+      // 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');
+        webKitLastResortFontSizes[fontRuler.getSize().width] = true;
+      }
+    }
+    fontRuler.remove();
+    return webKitLastResortFontSizes;
+  };
 
-  if (!this.webKitLastResortSizeChange_ && sizeA.width == sizeB.width &&
-      this.webKitLastResortFontSizes_[sizeA.width]) {
-    this.webKitLastResortFontSizes_ = {};
-    this.webKitLastResortFontSizes_[sizeA.width] = true;
-    this.webKitLastResortSizeChange_ = true;
-  }
-  if ((this.lastObservedSizeA_.width != sizeA.width || this.lastObservedSizeB_.width != sizeB.width) &&
-      (!this.webKitLastResortFontSizes_[sizeA.width] &&
-       !this.webKitLastResortFontSizes_[sizeB.width])) {
-    this.finish_(this.activeCallback_);
-  } else if (this.getTime_() - this.started_ >= 5000) {
+  /**
+   * @override
+   */
+  LastResortWebKitFontWatchRunner.prototype.check_ = function() {
+    var sizeA = this.fontRulerA_.getSize();
+    var sizeB = this.fontRulerB_.getSize();
 
-    // 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
-    // after 5 seconds if the latest 2 sizes are in webKitLastResortFontSizes_
-    // and the font name is known to be metrics compatible.
-    if (this.webKitLastResortFontSizes_[sizeA.width]
-        && this.webKitLastResortFontSizes_[sizeB.width] &&
-        webfont.LastResortWebKitFontWatchRunner.METRICS_COMPATIBLE_FONTS[
-          this.fontFamily_]) {
+    if (!this.webKitLastResortSizeChange_ && sizeA.width == sizeB.width &&
+        this.webKitLastResortFontSizes_[sizeA.width]) {
+      this.webKitLastResortFontSizes_ = {};
+      this.webKitLastResortFontSizes_[sizeA.width] = true;
+      this.webKitLastResortSizeChange_ = true;
+    }
+    if ((this.lastObservedSizeA_.width != sizeA.width || this.lastObservedSizeB_.width != sizeB.width) &&
+        (!this.webKitLastResortFontSizes_[sizeA.width] &&
+         !this.webKitLastResortFontSizes_[sizeB.width])) {
       this.finish_(this.activeCallback_);
+    } else if (goog.now() - this.started_ >= 5000) {
+
+      // 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
+      // after 5 seconds if the latest 2 sizes are in webKitLastResortFontSizes_
+      // and the font name is known to be metrics compatible.
+      if (this.webKitLastResortFontSizes_[sizeA.width]
+          && this.webKitLastResortFontSizes_[sizeB.width] &&
+          LastResortWebKitFontWatchRunner.METRICS_COMPATIBLE_FONTS[
+            this.fontFamily_]) {
+        this.finish_(this.activeCallback_);
+      } else {
+        this.finish_(this.inactiveCallback_);
+      }
     } else {
-      this.finish_(this.inactiveCallback_);
+      this.asyncCheck_();
     }
-  } else {
-    this.asyncCheck_();
-  }
-};
+  };
+});

data/src/modules.yml

@@ -1,19 +1,19 @@
 core:
-  - core/namespace.js
+  - ../tools/compiler/base.js
   - core/domhelper.js
   - core/browserinfo.js
   - core/useragent.js
   - core/useragentparser.js
+  - core/cssclassname.js
+  - core/cssfontfamilyname.js
+  - core/fontvariationdescription.js
   - core/eventdispatcher.js
   - core/fontmoduleloader.js
   - core/size.js
-  - core/fontwatcher.js
-  - core/fontwatchrunner.js
   - core/fontruler.js
+  - core/fontwatchrunner.js
+  - core/fontwatcher.js
   - core/font.js
-  - core/cssclassname.js
-  - core/cssfontfamilyname.js
-  - core/fontvariationdescription.js
   - core/initialize.js
 
 ascender:

data/src/monotype/monotype_script.js

@@ -1,3 +1,5 @@
+goog.provide('webfont.MonotypeScript');
+
 /**
 webfont.load({
 monotype: {
@@ -8,6 +10,7 @@ projectId: 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'//this is your Fonts.com Web fo
 
 /**
  * @constructor
+ * @implements {webfont.FontModule}
  */
 webfont.MonotypeScript = function (userAgent, domHelper, configuration) {
   this.userAgent_ = userAgent;
@@ -36,56 +39,60 @@ webfont.MonotypeScript.HOOK = '__mti_fntLst';
  */
 webfont.MonotypeScript.SCRIPTID = '__MonotypeAPIScript__';
 
-webfont.MonotypeScript.prototype.supportUserAgent = function (userAgent, support) {
-  var self = this;
-  var projectId = self.configuration_['projectId'];
-  var version = self.configuration_['version'];
-  if (projectId) {
-    var sc = self.domHelper_.createElement("script");
-    sc["id"] = webfont.MonotypeScript.SCRIPTID + projectId;
+goog.scope(function () {
+  var MonotypeScript = webfont.MonotypeScript;
+
+  MonotypeScript.prototype.supportUserAgent = function (userAgent, support) {
+    var self = this;
+    var projectId = self.configuration_['projectId'];
+    var version = self.configuration_['version'];
+    if (projectId) {
+      var sc = self.domHelper_.createElement("script");
+      sc["id"] = MonotypeScript.SCRIPTID + projectId;
 
-    var loadWindow = this.domHelper_.getLoadWindow();
+      var loadWindow = this.domHelper_.getLoadWindow();
 
-    function onload() {
-      if (loadWindow[webfont.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"]);
+      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"]);
+            }
           }
         }
+        support(userAgent.getBrowserInfo().hasWebFontSupport());
       }
-      support(userAgent.getBrowserInfo().hasWebFontSupport());
-    }
 
-    var done = false;
+      var done = false;
 
-    sc["onload"] = sc["onreadystatechange"] = function () {
-      if (!done && (!this["readyState"] || this["readyState"] === "loaded" || this["readyState"] === "complete")) {
-        done = true;
-        onload();
-        sc["onload"] = sc["onreadystatechange"] = null;
-      }
-    };
+      sc["onload"] = sc["onreadystatechange"] = function () {
+        if (!done && (!this["readyState"] || this["readyState"] === "loaded" || this["readyState"] === "complete")) {
+          done = true;
+          onload();
+          sc["onload"] = sc["onreadystatechange"] = null;
+        }
+      };
 
-    sc["src"] = self.getScriptSrc(projectId, version);
-    this.domHelper_.insertInto('head', sc);
-  }
-  else {
-    support(true);
-  }
-};
+      sc["src"] = self.getScriptSrc(projectId, version);
+      this.domHelper_.insertInto('head', sc);
+    }
+    else {
+      support(true);
+    }
+  };
 
-webfont.MonotypeScript.prototype.getScriptSrc = function (projectId, version) {
-  var p = this.domHelper_.getProtocol();
-  var api = (this.configuration_['api'] || 'fast.fonts.com/jsapi').replace(/^.*http(s?):(\/\/)?/, "");
-  return p + "//" + api + '/' + projectId + '.js' + ( version ? '?v='+ version : '' );
-};
+  MonotypeScript.prototype.getScriptSrc = function (projectId, version) {
+    var p = this.domHelper_.getProtocol();
+    var api = (this.configuration_['api'] || 'fast.fonts.com/jsapi').replace(/^.*http(s?):(\/\/)?/, "");
+    return p + "//" + api + '/' + projectId + '.js' + ( version ? '?v='+ version : '' );
+  };
 
-webfont.MonotypeScript.prototype.load = function (onReady) {
-  onReady(this.fontFamilies_, this.fontVariations_);
-};
+  MonotypeScript.prototype.load = function (onReady) {
+    onReady(this.fontFamilies_, this.fontVariations_);
+  };
+});
 
 globalNamespaceObject.addModule(webfont.MonotypeScript.NAME, function (configuration, domHelper) {
   var userAgentParser = new webfont.UserAgentParser(navigator.userAgent, document);

data/src/typekit/typekit_script.js

@@ -1,5 +1,8 @@
+goog.provide('webfont.TypekitScript');
+
 /**
  * @constructor
+ * @implements {webfont.FontModule}
  */
 webfont.TypekitScript = function(domHelper, configuration) {
   this.domHelper_ = domHelper;
@@ -11,49 +14,52 @@ webfont.TypekitScript = function(domHelper, configuration) {
 webfont.TypekitScript.NAME = 'typekit';
 webfont.TypekitScript.HOOK = '__webfonttypekitmodule__';
 
-webfont.TypekitScript.prototype.getScriptSrc = function(kitId) {
-  var protocol = this.domHelper_.getProtocol();
-  var api = this.configuration_['api'] || protocol + '//use.typekit.net';
-  return api + '/' + kitId + '.js';
-};
+goog.scope(function () {
+  var TypekitScript = webfont.TypekitScript;
 
-webfont.TypekitScript.prototype.supportUserAgent = function(userAgent, support) {
-  var kitId = this.configuration_['id'];
-  var configuration = this.configuration_;
-  var loadWindow = this.domHelper_.getLoadWindow();
-  var self = this;
+  TypekitScript.prototype.getScriptSrc = function(kitId) {
+    var protocol = this.domHelper_.getProtocol();
+    var api = this.configuration_['api'] || protocol + '//use.typekit.net';
+    return api + '/' + kitId + '.js';
+  };
 
-  if (kitId) {
-    // Provide data to Typekit for processing.main
-    if (!loadWindow[webfont.TypekitScript.HOOK]) {
-      loadWindow[webfont.TypekitScript.HOOK] = {};
-    }
+  TypekitScript.prototype.supportUserAgent = function(userAgent, support) {
+    var kitId = this.configuration_['id'];
+    var configuration = this.configuration_;
+    var loadWindow = this.domHelper_.getLoadWindow();
+    var self = this;
 
-    // Typekit will call 'init' to indicate whether it supports fonts
-    // and what fonts will be provided.
-    loadWindow[webfont.TypekitScript.HOOK][kitId] = function(callback) {
-      var init = function(typekitSupports, fontFamilies, fontVariations) {
-        self.fontFamilies_ = fontFamilies;
-        self.fontVariations_ = fontVariations;
-        support(typekitSupports);
+    if (kitId) {
+      // Provide data to Typekit for processing.main
+      if (!loadWindow[webfont.TypekitScript.HOOK]) {
+        loadWindow[webfont.TypekitScript.HOOK] = {};
+      }
+
+      // Typekit will call 'init' to indicate whether it supports fonts
+      // and what fonts will be provided.
+      loadWindow[webfont.TypekitScript.HOOK][kitId] = function(callback) {
+        var init = function(typekitSupports, fontFamilies, fontVariations) {
+          self.fontFamilies_ = fontFamilies;
+          self.fontVariations_ = fontVariations;
+          support(typekitSupports);
+        };
+        callback(userAgent, configuration, init);
       };
-      callback(userAgent, configuration, init);
-    };
 
-    // Load the Typekit script.
-    var script = this.domHelper_.createScriptSrc(this.getScriptSrc(kitId))
-    this.domHelper_.insertInto('head', script);
+      // Load the Typekit script.
+      var script = this.domHelper_.createScriptSrc(this.getScriptSrc(kitId))
+      this.domHelper_.insertInto('head', script);
 
-  } else {
-    support(true);
-  }
-};
+    } else {
+      support(true);
+    }
+  };
 
-webfont.TypekitScript.prototype.load = function(onReady) {
-  onReady(this.fontFamilies_, this.fontVariations_);
-};
+  TypekitScript.prototype.load = function(onReady) {
+    onReady(this.fontFamilies_, this.fontVariations_);
+  };
+});
 
 globalNamespaceObject.addModule(webfont.TypekitScript.NAME, function(configuration, domHelper) {
   return new webfont.TypekitScript(domHelper, configuration);
 });
-