webfontloader 1.3.0 → 1.3.1

data/src/custom/customcss.js

@@ -1,3 +1,5 @@
+goog.provide('webfont.CustomCss');
+
 /**
  *
  * WebFont.load({
@@ -7,6 +9,7 @@
  * });
  *
  * @constructor
+ * @implements {webfont.FontModule}
  */
 webfont.CustomCss = function(domHelper, configuration) {
   this.domHelper_ = domHelper;
@@ -15,38 +18,42 @@ webfont.CustomCss = function(domHelper, configuration) {
 
 webfont.CustomCss.NAME = 'custom';
 
-webfont.CustomCss.prototype.load = function(onReady) {
-  var i, len;
-  var urls = this.configuration_['urls'] || [];
-  var familiesConfiguration = this.configuration_['families'] || [];
+goog.scope(function () {
+  var CustomCss = webfont.CustomCss;
+
+  CustomCss.prototype.load = function(onReady) {
+    var i, len;
+    var urls = this.configuration_['urls'] || [];
+    var familiesConfiguration = this.configuration_['families'] || [];
 
-  for (i = 0, len = urls.length; i < len; i++) {
-    var url = urls[i];
+    for (i = 0, len = urls.length; i < len; i++) {
+      var url = urls[i];
 
-    this.domHelper_.insertInto('head', this.domHelper_.createCssLink(url));
-  }
+      this.domHelper_.insertInto('head', this.domHelper_.createCssLink(url));
+    }
 
-  var families = [];
-  var variations = {};
-  for (i = 0, len = familiesConfiguration.length; i < len; i++) {
-    var components = familiesConfiguration[i].split(":");
-    var family = components[0];
-    var familyVariations = components[1];
+    var families = [];
+    var variations = {};
+    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);
+      families.push(family);
 
-    if (familyVariations) {
-      var newVariations = familyVariations.split(",");
-      variations[family] = (variations[family] || []).concat(newVariations);
+      if (familyVariations) {
+        var newVariations = familyVariations.split(",");
+        variations[family] = (variations[family] || []).concat(newVariations);
+      }
     }
-  }
 
-  onReady(families, variations);
-};
+    onReady(families, variations);
+  };
 
-webfont.CustomCss.prototype.supportUserAgent = function(userAgent, support) {
-  return support(userAgent.getBrowserInfo().hasWebFontSupport());
-};
+  CustomCss.prototype.supportUserAgent = function(userAgent, support) {
+    return support(userAgent.getBrowserInfo().hasWebFontSupport());
+  };
+});
 
 globalNamespaceObject.addModule(webfont.CustomCss.NAME, function(configuration, domHelper) {
   return new webfont.CustomCss(domHelper, configuration);

data/src/fontdeck/fontdeck_script.js

@@ -1,5 +1,10 @@
+goog.provide('webfont.FontdeckScript');
+
+goog.require('webfont.FontVariationDescription');
+
 /**
  * @constructor
+ * @implements {webfont.FontModule}
  */
 webfont.FontdeckScript = function(domHelper, configuration) {
   this.domHelper_ = domHelper;
@@ -13,50 +18,54 @@ webfont.FontdeckScript.NAME = 'fontdeck';
 webfont.FontdeckScript.HOOK = '__webfontfontdeckmodule__';
 webfont.FontdeckScript.API = '//f.fontdeck.com/s/css/js/';
 
-webfont.FontdeckScript.prototype.getScriptSrc = function(projectId) {
-  var protocol = this.domHelper_.getProtocol();
-  // For empty iframes, fall back to main window's hostname.
-  var hostname = this.domHelper_.getLoadWindow().location.hostname ||
-      this.domHelper_.getMainWindow().location.hostname;
-  var api = this.configuration_['api'] || webfont.FontdeckScript.API;
-  return protocol + api + hostname + '/' + projectId + '.js';
-};
+goog.scope(function () {
+  var FontdeckScript = webfont.FontdeckScript;
 
-webfont.FontdeckScript.prototype.supportUserAgent = function(userAgent, support) {
-  var projectId = this.configuration_['id'];
-  var loadWindow = this.domHelper_.getLoadWindow();
-  var self = this;
+  FontdeckScript.prototype.getScriptSrc = function(projectId) {
+    var protocol = this.domHelper_.getProtocol();
+    // For empty iframes, fall back to main window's hostname.
+    var hostname = this.domHelper_.getLoadWindow().location.hostname ||
+        this.domHelper_.getMainWindow().location.hostname;
+    var api = this.configuration_['api'] || webfont.FontdeckScript.API;
+    return protocol + api + hostname + '/' + projectId + '.js';
+  };
 
-  if (projectId) {
-    // Provide data to Fontdeck for processing.
-    if (!loadWindow[webfont.FontdeckScript.HOOK]) {
-      loadWindow[webfont.FontdeckScript.HOOK] = {};
-    }
+  FontdeckScript.prototype.supportUserAgent = function(userAgent, support) {
+    var projectId = this.configuration_['id'];
+    var loadWindow = this.domHelper_.getLoadWindow();
+    var self = this;
 
-    // Fontdeck will call this function to indicate support status
-    // and what fonts are provided.
-    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'])];
+    if (projectId) {
+      // Provide data to Fontdeck for processing.
+      if (!loadWindow[webfont.FontdeckScript.HOOK]) {
+        loadWindow[webfont.FontdeckScript.HOOK] = {};
       }
-      support(fontdeckSupports);
-    };
 
-    // Call the Fontdeck API.
-    var script = this.domHelper_.createScriptSrc(this.getScriptSrc(projectId));
-    this.domHelper_.insertInto('head', script);
+      // Fontdeck will call this function to indicate support status
+      // and what fonts are provided.
+      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'])];
+        }
+        support(fontdeckSupports);
+      };
 
-  } else {
-    support(true);
-  }
-};
+      // Call the Fontdeck API.
+      var script = this.domHelper_.createScriptSrc(this.getScriptSrc(projectId));
+      this.domHelper_.insertInto('head', script);
 
-webfont.FontdeckScript.prototype.load = function(onReady) {
-  onReady(this.fontFamilies_, this.fontVariations_);
-};
+    } else {
+      support(true);
+    }
+  };
+
+  FontdeckScript.prototype.load = function(onReady) {
+    onReady(this.fontFamilies_, this.fontVariations_);
+  };
+});
 
 globalNamespaceObject.addModule(webfont.FontdeckScript.NAME, function(configuration, domHelper) {
   return new webfont.FontdeckScript(domHelper, configuration);

data/src/google/fontapiparser.js

@@ -1,3 +1,7 @@
+goog.provide('webfont.FontApiParser');
+
+goog.require('webfont.FontVariationDescription');
+
 /**
  * @constructor
  */
@@ -56,122 +60,126 @@ webfont.FontApiParser.VARIATION_MATCH =
         "(?:(?:semi|demi|extra|ultra)-?)?bold|black|heavy|l|r|b|[1-9]00)?(n|i" +
         "|normal|italic)?$");
 
-webfont.FontApiParser.prototype.parse = function() {
-  var length = this.fontFamilies_.length;
-
-  for (var i = 0; i < length; i++) {
-    var elements = this.fontFamilies_[i].split(":");
-    var fontFamily = elements[0].replace(/\+/g, " ");
-    var variations = ['n4'];
-
-    if (elements.length >= 2) {
-      var fvds = this.parseVariations_(elements[1]);
-
-      if (fvds.length > 0) {
-        variations = fvds;
-      }
-      if (elements.length == 3) {
-        var subsets = this.parseSubsets_(elements[2]);
-        if (subsets.length > 0) {
-          var fontTestString = webfont.FontApiParser.INT_FONTS[subsets[0]];
-
-          if (fontTestString) {
-	    this.fontTestStrings_[fontFamily] = fontTestString;
-	  }
-	}
+goog.scope(function () {
+  var FontApiParser = webfont.FontApiParser;
+
+  FontApiParser.prototype.parse = function() {
+    var length = this.fontFamilies_.length;
+
+    for (var i = 0; i < length; i++) {
+      var elements = this.fontFamilies_[i].split(":");
+      var fontFamily = elements[0].replace(/\+/g, " ");
+      var variations = ['n4'];
+
+      if (elements.length >= 2) {
+        var fvds = this.parseVariations_(elements[1]);
+
+        if (fvds.length > 0) {
+          variations = fvds;
+        }
+        if (elements.length == 3) {
+          var subsets = this.parseSubsets_(elements[2]);
+          if (subsets.length > 0) {
+            var fontTestString = FontApiParser.INT_FONTS[subsets[0]];
+
+            if (fontTestString) {
+              this.fontTestStrings_[fontFamily] = fontTestString;
+            }
+          }
+        }
       }
-    }
 
-    // For backward compatibility
-    if (!this.fontTestStrings_[fontFamily]) {
-      var hanumanTestString = webfont.FontApiParser.INT_FONTS[fontFamily];
-      if (hanumanTestString) {
-        this.fontTestStrings_[fontFamily] = hanumanTestString;
+      // For backward compatibility
+      if (!this.fontTestStrings_[fontFamily]) {
+        var hanumanTestString = FontApiParser.INT_FONTS[fontFamily];
+        if (hanumanTestString) {
+          this.fontTestStrings_[fontFamily] = hanumanTestString;
+        }
       }
+      this.parsedFontFamilies_.push(fontFamily);
+      this.variations_[fontFamily] = variations;
     }
-    this.parsedFontFamilies_.push(fontFamily);
-    this.variations_[fontFamily] = variations;
-  }
-};
+  };
 
-webfont.FontApiParser.prototype.generateFontVariationDescription_ = function(variation) {
-  if (!variation.match(/^[\w]+$/)) {
-    return '';
-  }
-  var normalizedVariation = variation.toLowerCase();
-  var groups = webfont.FontApiParser.VARIATION_MATCH.exec(normalizedVariation);
-  if (groups == null) {
-    return '';
-  }
-  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;
-};
+  FontApiParser.prototype.generateFontVariationDescription_ = function(variation) {
+    if (!variation.match(/^[\w]+$/)) {
+      return '';
+    }
+    var normalizedVariation = variation.toLowerCase();
+    var groups = FontApiParser.VARIATION_MATCH.exec(normalizedVariation);
+    if (groups == null) {
+      return '';
+    }
+    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;
+  };
 
 
-webfont.FontApiParser.prototype.normalizeStyle_ = function(parsedStyle) {
-  if (parsedStyle == null) {
-    return 'n';
-  }
-  return webfont.FontApiParser.STYLES[parsedStyle];
-};
+  FontApiParser.prototype.normalizeStyle_ = function(parsedStyle) {
+    if (parsedStyle == null || parsedStyle == '') {
+      return 'n';
+    }
+    return FontApiParser.STYLES[parsedStyle];
+  };
 
 
-webfont.FontApiParser.prototype.normalizeWeight_ = function(parsedWeight) {
-  if (parsedWeight == null) {
-    return '4';
-  }
-  var weight = webfont.FontApiParser.WEIGHTS[parsedWeight];
-  if (weight) {
-    return weight;
-  }
-  if (isNaN(parsedWeight)) {
-    return '4';
-  }
-  return parsedWeight.substr(0, 1);
-};
+  FontApiParser.prototype.normalizeWeight_ = function(parsedWeight) {
+    if (parsedWeight == null || parsedWeight == '') {
+      return '4';
+    }
+    var weight = FontApiParser.WEIGHTS[parsedWeight];
+    if (weight) {
+      return weight;
+    }
+    if (isNaN(parsedWeight)) {
+      return '4';
+    }
+    return parsedWeight.substr(0, 1);
+  };
 
 
-webfont.FontApiParser.prototype.parseVariations_ = function(variations) {
-  var finalVariations = [];
+  FontApiParser.prototype.parseVariations_ = function(variations) {
+    var finalVariations = [];
 
-  if (!variations) {
-    return finalVariations;
-  }
-  var providedVariations = variations.split(",");
-  var length = providedVariations.length;
+    if (!variations) {
+      return finalVariations;
+    }
+    var providedVariations = variations.split(",");
+    var length = providedVariations.length;
 
-  for (var i = 0; i < length; i++) {
-    var variation = providedVariations[i];
-    var fvd = this.generateFontVariationDescription_(variation);
+    for (var i = 0; i < length; i++) {
+      var variation = providedVariations[i];
+      var fvd = this.generateFontVariationDescription_(variation);
 
-    if (fvd) {
-      finalVariations.push(fvd);
+      if (fvd) {
+        finalVariations.push(fvd);
+      }
     }
-  }
-  return finalVariations;
-};
+    return finalVariations;
+  };
 
 
-webfont.FontApiParser.prototype.parseSubsets_ = function(subsets) {
-  var finalSubsets = [];
+  FontApiParser.prototype.parseSubsets_ = function(subsets) {
+    var finalSubsets = [];
 
-  if (!subsets) {
-    return finalSubsets;
-  }
-  return subsets.split(",");
-};
+    if (!subsets) {
+      return finalSubsets;
+    }
+    return subsets.split(",");
+  };
 
 
-webfont.FontApiParser.prototype.getFontFamilies = function() {
-  return this.parsedFontFamilies_;
-};
+  FontApiParser.prototype.getFontFamilies = function() {
+    return this.parsedFontFamilies_;
+  };
 
-webfont.FontApiParser.prototype.getVariations = function() {
-  return this.variations_;
-};
+  FontApiParser.prototype.getVariations = function() {
+    return this.variations_;
+  };
 
-webfont.FontApiParser.prototype.getFontTestStrings = function() {
-  return this.fontTestStrings_;
-};
+  FontApiParser.prototype.getFontTestStrings = function() {
+    return this.fontTestStrings_;
+  };
+});

data/src/google/fontapiurlbuilder.js

@@ -1,3 +1,5 @@
+goog.provide('webfont.FontApiUrlBuilder');
+
 /**
  * @constructor
  */
@@ -15,58 +17,61 @@ webfont.FontApiUrlBuilder = function(apiUrl, protocol, text) {
 
 webfont.FontApiUrlBuilder.DEFAULT_API_URL = '//fonts.googleapis.com/css';
 
+goog.scope(function () {
+  var FontApiUrlBuilder = webfont.FontApiUrlBuilder;
 
-webfont.FontApiUrlBuilder.prototype.setFontFamilies = function(fontFamilies) {
-  this.parseFontFamilies_(fontFamilies);
-};
+  FontApiUrlBuilder.prototype.setFontFamilies = function(fontFamilies) {
+    this.parseFontFamilies_(fontFamilies);
+  };
 
 
-webfont.FontApiUrlBuilder.prototype.parseFontFamilies_ =
-    function(fontFamilies) {
-  var length = fontFamilies.length;
+  FontApiUrlBuilder.prototype.parseFontFamilies_ =
+      function(fontFamilies) {
+    var length = fontFamilies.length;
 
-  for (var i = 0; i < length; i++) {
-    var elements = fontFamilies[i].split(':');
+    for (var i = 0; i < length; i++) {
+      var elements = fontFamilies[i].split(':');
 
-    if (elements.length == 3) {
-      this.subsets_.push(elements.pop());
-    }
-    var joinCharacter = '';
-    if (elements.length == 2 && elements[1] != ''){
-      joinCharacter = ':';
+      if (elements.length == 3) {
+        this.subsets_.push(elements.pop());
+      }
+      var joinCharacter = '';
+      if (elements.length == 2 && elements[1] != ''){
+        joinCharacter = ':';
+      }
+      this.fontFamilies_.push(elements.join(joinCharacter));
     }
-    this.fontFamilies_.push(elements.join(joinCharacter));
-  }
-};
+  };
 
 
-webfont.FontApiUrlBuilder.prototype.webSafe = function(string) {
-  return string.replace(/ /g, '+');
-};
+  FontApiUrlBuilder.prototype.webSafe = function(string) {
+    return string.replace(/ /g, '+');
+  };
 
 
-webfont.FontApiUrlBuilder.prototype.build = function() {
-  if (this.fontFamilies_.length == 0) {
-    throw new Error('No fonts to load !');
-  }
-  if (this.apiUrl_.indexOf("kit=") != -1) {
-    return this.apiUrl_;
-  }
-  var length = this.fontFamilies_.length;
-  var sb = [];
+  FontApiUrlBuilder.prototype.build = function() {
+    if (this.fontFamilies_.length == 0) {
+      throw new Error('No fonts to load !');
+    }
+    if (this.apiUrl_.indexOf("kit=") != -1) {
+      return this.apiUrl_;
+    }
+    var length = this.fontFamilies_.length;
+    var sb = [];
 
-  for (var i = 0; i < length; i++) {
-    sb.push(this.webSafe(this.fontFamilies_[i]));
-  }
-  var url = this.apiUrl_ + '?family=' + sb.join('%7C'); // '|' escaped.
+    for (var i = 0; i < length; i++) {
+      sb.push(this.webSafe(this.fontFamilies_[i]));
+    }
+    var url = this.apiUrl_ + '?family=' + sb.join('%7C'); // '|' escaped.
 
-  if (this.subsets_.length > 0) {
-    url += '&subset=' + this.subsets_.join(',');
-  }
+    if (this.subsets_.length > 0) {
+      url += '&subset=' + this.subsets_.join(',');
+    }
 
-  if (this.text_.length > 0) {
-    url += '&text=' + encodeURIComponent(this.text_);
-  }
+    if (this.text_.length > 0) {
+      url += '&text=' + encodeURIComponent(this.text_);
+    }
 
-  return url;
-};
+    return url;
+  };
+});