webfontloader 1.5.8 → 1.5.9

data/spec/modules/monotype_spec.js

@@ -34,13 +34,10 @@ describe('modules.Monotype', function () {
     useragent = new UserAgent(
       'Firefox',
       new Version(3, 6),
-      '3.6',
       'Gecko',
       new Version(1, 9, 3),
-      '1.9.3',
       'Macintosh',
       new Version(10, 6),
-      '10.6',
       undefined,
       new BrowserInfo(true, false, false, false)
     );

data/spec/modules/typekit_spec.js

@@ -12,65 +12,41 @@ describe('modules.Typekit', function () {
       support = null;
 
   beforeEach(function () {
-    global = {};
+    global = {
+      Typekit: {
+        config: {
+          fn: ['Font1', ['n4'], 'Font2', ['n4', 'n7']]
+        },
+        load: jasmine.createSpy('load')
+      }
+    };
 
     support = jasmine.createSpy('support');
 
     load = jasmine.createSpy('load');
 
     fakeDomHelper = {
-      loadScript: jasmine.createSpy('loadScript'),
+      loadScript: jasmine.createSpy('loadScript').andCallFake(function (url, cb) {
+        cb(null);
+      }),
       getLoadWindow: jasmine.createSpy('getLoadWindow').andReturn(global),
       getProtocol: jasmine.createSpy('getProtocol').andReturn('http:')
     };
   });
 
-  it('support load and life cycle', function () {
+  it('should load with variations', function () {
     var typekit = new Typekit(fakeDomHelper, configuration);
 
     typekit.supportUserAgent('useragent', support);
 
     expect(fakeDomHelper.loadScript).toHaveBeenCalled();
     expect(fakeDomHelper.loadScript.calls[0].args[0]).toEqual('http://use.typekit.net/abc.js');
-    expect(support).not.toHaveBeenCalled();
-
-    expect(global.__webfonttypekitmodule__).not.toBeNull();
-    expect(global.__webfonttypekitmodule__['abc']).not.toBeNull();
-
-    global.__webfonttypekitmodule__['abc'](function (ua, config, init) {
-      expect(ua).toEqual('useragent');
-      expect(config).toEqual(configuration);
-      expect(init).not.toBeNull();
-      init(true, ['Font1', 'Font2'], {});
-    });
-
-    expect(support).toHaveBeenCalled();
-
-    typekit.load(load);
-
-    expect(load).toHaveBeenCalledWith([new Font('Font1'), new Font('Font2')]);
-  });
-
-  it('should load with variations', function () {
-    var typekit = new Typekit(fakeDomHelper, configuration);
-
-    typekit.supportUserAgent('useragent', support);
-
-    global.__webfonttypekitmodule__['abc'](function (ua, config, init) {
-      init(true, ['Font1', 'Font2'], {
-        'Font1': ['n7', 'i7']
-      });
-    });
-
     expect(support).toHaveBeenCalled();
 
+    expect(global.Typekit.load).toHaveBeenCalled();
     typekit.load(load);
 
-    expect(load).toHaveBeenCalledWith([
-      new Font('Font1', 'n7'),
-      new Font('Font1', 'i7'),
-      new Font('Font2', 'n4')
-    ]);
+    expect(load).toHaveBeenCalledWith([new Font('Font1', 'n4'), new Font('Font2', 'n4'), new Font('Font2', 'n7')]);
   });
 
   it('should load through the alternative API', function () {

data/src/core/eventdispatcher.js

@@ -12,15 +12,18 @@ goog.require('webfont.CssClassName');
  * @param {HTMLElement} htmlElement
  * @param {Object} callbacks
  * @param {string=} opt_namespace
+ * @param {boolean=} opt_dispatchEvents Set to false to not call any callbacks. Defaults to true.
+ * @param {boolean=} opt_setClasses Set to false to not set classes on the HTML element. Defaults to true.
  * @constructor
  */
-webfont.EventDispatcher = function(domHelper, htmlElement, callbacks,
-    opt_namespace) {
+webfont.EventDispatcher = function(domHelper, htmlElement, callbacks, opt_namespace, opt_dispatchEvents, opt_setClasses) {
   this.domHelper_ = domHelper;
   this.htmlElement_ = htmlElement;
   this.callbacks_ = callbacks;
   this.namespace_ = opt_namespace || webfont.EventDispatcher.DEFAULT_NAMESPACE;
   this.cssClassName_ = new webfont.CssClassName('-');
+  this.dispatchEvents_ = opt_dispatchEvents !== false;
+  this.setClasses_ = opt_setClasses !== false;
 };
 
 /**
@@ -60,11 +63,13 @@ goog.scope(function () {
    * Dispatch the loading event and append the loading class name.
    */
   EventDispatcher.prototype.dispatchLoading = function() {
-    this.domHelper_.updateClassName(this.htmlElement_,
-      [
-        this.cssClassName_.build(this.namespace_, webfont.EventDispatcher.LOADING)
-      ]
-    );
+    if (this.setClasses_) {
+      this.domHelper_.updateClassName(this.htmlElement_,
+        [
+          this.cssClassName_.build(this.namespace_, webfont.EventDispatcher.LOADING)
+        ]
+      );
+    }
 
     this.dispatch_(webfont.EventDispatcher.LOADING);
   };
@@ -74,14 +79,15 @@ goog.scope(function () {
    * @param {webfont.Font} font
    */
   EventDispatcher.prototype.dispatchFontLoading = function(font) {
-    this.domHelper_.updateClassName(this.htmlElement_,
-      [
-        this.cssClassName_.build(this.namespace_, font.getName(), font.getVariation().toString(), webfont.EventDispatcher.LOADING)
-      ]
-    );
-
-    this.dispatch_(
-        webfont.EventDispatcher.FONT + webfont.EventDispatcher.LOADING, font);
+    if (this.setClasses_) {
+      this.domHelper_.updateClassName(this.htmlElement_,
+        [
+          this.cssClassName_.build(this.namespace_, font.getName(), font.getVariation().toString(), webfont.EventDispatcher.LOADING)
+        ]
+      );
+    }
+
+    this.dispatch_(webfont.EventDispatcher.FONT + webfont.EventDispatcher.LOADING, font);
   };
 
   /**
@@ -90,16 +96,18 @@ goog.scope(function () {
    * @param {webfont.Font} font
    */
   EventDispatcher.prototype.dispatchFontActive = function(font) {
-    this.domHelper_.updateClassName(
-      this.htmlElement_,
-      [
-        this.cssClassName_.build(this.namespace_, font.getName(), font.getVariation().toString(), webfont.EventDispatcher.ACTIVE)
-      ],
-      [
-        this.cssClassName_.build(this.namespace_, font.getName(), font.getVariation().toString(), webfont.EventDispatcher.LOADING),
-        this.cssClassName_.build(this.namespace_, font.getName(), font.getVariation().toString(), webfont.EventDispatcher.INACTIVE)
-      ]
-    );
+    if (this.setClasses_) {
+      this.domHelper_.updateClassName(
+        this.htmlElement_,
+        [
+          this.cssClassName_.build(this.namespace_, font.getName(), font.getVariation().toString(), webfont.EventDispatcher.ACTIVE)
+        ],
+        [
+          this.cssClassName_.build(this.namespace_, font.getName(), font.getVariation().toString(), webfont.EventDispatcher.LOADING),
+          this.cssClassName_.build(this.namespace_, font.getName(), font.getVariation().toString(), webfont.EventDispatcher.INACTIVE)
+        ]
+      );
+    }
 
     this.dispatch_(webfont.EventDispatcher.FONT + webfont.EventDispatcher.ACTIVE, font);
   };
@@ -111,20 +119,22 @@ goog.scope(function () {
    * @param {webfont.Font} font
    */
   EventDispatcher.prototype.dispatchFontInactive = function(font) {
-    var hasFontActive = this.domHelper_.hasClassName(this.htmlElement_,
-          this.cssClassName_.build(this.namespace_, font.getName(), font.getVariation().toString(), webfont.EventDispatcher.ACTIVE)
-        ),
-        add = [],
-        remove = [
-          this.cssClassName_.build(this.namespace_, font.getName(), font.getVariation().toString(), webfont.EventDispatcher.LOADING)
-        ];
+    if (this.setClasses_) {
+      var hasFontActive = this.domHelper_.hasClassName(this.htmlElement_,
+            this.cssClassName_.build(this.namespace_, font.getName(), font.getVariation().toString(), webfont.EventDispatcher.ACTIVE)
+          ),
+          add = [],
+          remove = [
+            this.cssClassName_.build(this.namespace_, font.getName(), font.getVariation().toString(), webfont.EventDispatcher.LOADING)
+          ];
+
+      if (!hasFontActive) {
+        add.push(this.cssClassName_.build(this.namespace_, font.getName(), font.getVariation().toString(), webfont.EventDispatcher.INACTIVE));
+      }
 
-    if (!hasFontActive) {
-      add.push(this.cssClassName_.build(this.namespace_, font.getName(), font.getVariation().toString(), webfont.EventDispatcher.INACTIVE));
+      this.domHelper_.updateClassName(this.htmlElement_, add, remove);
     }
 
-    this.domHelper_.updateClassName(this.htmlElement_, add, remove);
-
     this.dispatch_(webfont.EventDispatcher.FONT + webfont.EventDispatcher.INACTIVE, font);
   };
 
@@ -133,20 +143,22 @@ goog.scope(function () {
    * inactive class name (unless the active class name is already present).
    */
   EventDispatcher.prototype.dispatchInactive = function() {
-    var hasActive = this.domHelper_.hasClassName(this.htmlElement_,
-          this.cssClassName_.build(this.namespace_, webfont.EventDispatcher.ACTIVE)
-        ),
-        add = [],
-        remove = [
-          this.cssClassName_.build(this.namespace_, webfont.EventDispatcher.LOADING)
-        ];
+    if (this.setClasses_) {
+      var hasActive = this.domHelper_.hasClassName(this.htmlElement_,
+            this.cssClassName_.build(this.namespace_, webfont.EventDispatcher.ACTIVE)
+          ),
+          add = [],
+          remove = [
+            this.cssClassName_.build(this.namespace_, webfont.EventDispatcher.LOADING)
+          ];
+
+      if (!hasActive) {
+        add.push(this.cssClassName_.build(this.namespace_, webfont.EventDispatcher.INACTIVE));
+      }
 
-    if (!hasActive) {
-      add.push(this.cssClassName_.build(this.namespace_, webfont.EventDispatcher.INACTIVE));
+      this.domHelper_.updateClassName(this.htmlElement_, add, remove);
     }
 
-    this.domHelper_.updateClassName(this.htmlElement_, add, remove);
-
     this.dispatch_(webfont.EventDispatcher.INACTIVE);
   };
 
@@ -155,15 +167,17 @@ goog.scope(function () {
    * class name, and append the active class name.
    */
   EventDispatcher.prototype.dispatchActive = function() {
-    this.domHelper_.updateClassName(this.htmlElement_,
-      [
-        this.cssClassName_.build(this.namespace_, webfont.EventDispatcher.ACTIVE)
-      ],
-      [
-        this.cssClassName_.build(this.namespace_, webfont.EventDispatcher.LOADING),
-        this.cssClassName_.build(this.namespace_, webfont.EventDispatcher.INACTIVE)
-      ]
-    );
+    if (this.setClasses_) {
+      this.domHelper_.updateClassName(this.htmlElement_,
+        [
+          this.cssClassName_.build(this.namespace_, webfont.EventDispatcher.ACTIVE)
+        ],
+        [
+          this.cssClassName_.build(this.namespace_, webfont.EventDispatcher.LOADING),
+          this.cssClassName_.build(this.namespace_, webfont.EventDispatcher.INACTIVE)
+        ]
+      );
+    }
 
     this.dispatch_(webfont.EventDispatcher.ACTIVE);
   };
@@ -173,7 +187,7 @@ goog.scope(function () {
    * @param {webfont.Font=} opt_font
    */
   EventDispatcher.prototype.dispatch_ = function(event, opt_font) {
-    if (this.callbacks_[event]) {
+    if (this.dispatchEvents_ && this.callbacks_[event]) {
       if (opt_font) {
         this.callbacks_[event](opt_font.getName(), opt_font.getVariation());
       } else {

data/src/core/fontruler.js

@@ -38,7 +38,7 @@ goog.scope(function () {
    * @return {string}
    */
   FontRuler.prototype.computeStyleString_ = function(font) {
-    return "display:block;position:absolute;top:-999px;left:-999px;" +
+    return "display:block;position:absolute;top:0px;left:0px;visibility:hidden;" +
            "font-size:300px;width:auto;height:auto;line-height:normal;margin:0;" +
            "padding:0;font-variant:normal;white-space:nowrap;font-family:" +
            font.getCssName() + ";" + font.getCssVariation();

data/src/core/fontwatcher.js

@@ -28,14 +28,15 @@ goog.scope(function () {
   /**
    * Watches a set of font families.
    * @param {Array.<webfont.Font>} fonts The fonts to watch.
-   * @param {Object.<string, string>} fontTestStrings The font test strings for
+   * @param {webfont.FontTestStrings} fontTestStrings The font test strings for
    *     each family.
    * @param {Object.<String, boolean>} metricCompatibleFonts
    * @param {boolean} last True if this is the last set of fonts to watch.
    */
   FontWatcher.prototype.watchFonts = function(fonts,
       fontTestStrings, metricCompatibleFonts, last) {
-    var length = fonts.length;
+    var length = fonts.length,
+        testStrings = fontTestStrings || {};
 
     if (length === 0 && last) {
       this.eventDispatcher_.dispatchInactive();
@@ -50,22 +51,33 @@ goog.scope(function () {
 
     for (var i = 0; i < fonts.length; i++) {
       var font = fonts[i],
-          fontTestString = fontTestStrings[font.getName()];
+          testString = testStrings[font.getName()];
 
       this.eventDispatcher_.dispatchFontLoading(font);
 
       var fontWatchRunner = null;
 
-      if (this.browserInfo_.hasNativeFontLoading()) {
-        fontWatchRunner = new NativeFontWatchRunner(
-            goog.bind(this.fontActive_, this),
-            goog.bind(this.fontInactive_, this),
-            this.domHelper_,
-            font,
-            this.timeout_,
-            fontTestString
-          );
-      } else {
+      // We've disabled the native font watch runner for now. The
+      // reason is that its behaviour is slightly different from
+      // the non-native version in that it returns immediately if
+      // a @font-face rule is not in the document. The non-native
+      // version keeps polling the page. A lot of modules depend
+      // on the ability to start font watching before actually
+      // loading the fonts, so they fail in this case (which is
+      // related to browser support; figuring out when a
+      // stylesheet has loaded reliably). Until that issue is
+      // resolved we'll keep the native font disabled.
+      //
+      //if (this.browserInfo_.hasNativeFontLoading()) {
+      //  fontWatchRunner = new NativeFontWatchRunner(
+      //      goog.bind(this.fontActive_, this),
+      //      goog.bind(this.fontInactive_, this),
+      //      this.domHelper_,
+      //      font,
+      //      this.timeout_,
+      //      fontTestString
+      //    );
+      //} else {
         fontWatchRunner = new FontWatchRunner(
             goog.bind(this.fontActive_, this),
             goog.bind(this.fontInactive_, this),
@@ -74,9 +86,9 @@ goog.scope(function () {
             this.browserInfo_,
             this.timeout_,
             metricCompatibleFonts,
-            fontTestString
+            testString
           );
-      }
+      //}
 
       fontWatchRunner.start();
     }

data/src/core/useragent.js

@@ -12,13 +12,10 @@ goog.provide('webfont.UserAgent');
  * @export
  * @param {string} name
  * @param {webfont.Version} version
- * @param {string} versionString
  * @param {string} engine
  * @param {webfont.Version} engineVersion
- * @param {string} engineVersionString
  * @param {string} platform
  * @param {webfont.Version} platformVersion
- * @param {string} platformVersionString
  * @param {number|undefined} documentMode
  * @param {!webfont.BrowserInfo} browserInfo
  * @constructor
@@ -26,24 +23,18 @@ goog.provide('webfont.UserAgent');
 webfont.UserAgent = function(
     name,
     version,
-    versionString,
     engine,
     engineVersion,
-    engineVersionString,
     platform,
     platformVersion,
-    platformVersionString,
     documentMode,
     browserInfo) {
   this.name_ = name;
   this.version_ = version;
-  this.versionString_ = versionString;
   this.engine_ = engine;
   this.engineVersion_ = engineVersion;
-  this.engineVersionString_ = engineVersionString;
   this.platform_ = platform;
   this.platformVersion_ = platformVersion;
-  this.platformVersionString_ = platformVersionString;
   this.documentMode_ = documentMode;
   this.browserInfo_ = browserInfo;
 };
@@ -59,19 +50,10 @@ goog.scope(function () {
     return this.name_;
   };
 
-  /**
-   * @export
-   * @deprecated
-   * @return {string}
-   */
-  UserAgent.prototype.getVersion = function() {
-    return this.versionString_;
-  };
-
   /**
    * @return {webfont.Version}
    */
-  UserAgent.prototype.getParsedVersion = function() {
+  UserAgent.prototype.getVersion = function() {
     return this.version_;
   };
 
@@ -83,19 +65,10 @@ goog.scope(function () {
     return this.engine_;
   };
 
-  /**
-   * @export
-   * @deprecated
-   * @return {string}
-   */
-  UserAgent.prototype.getEngineVersion = function() {
-    return this.engineVersionString_;
-  };
-
   /**
    * @return {webfont.Version}
    */
-  UserAgent.prototype.getParsedEngineVersion = function() {
+  UserAgent.prototype.getEngineVersion = function() {
     return this.engineVersion_;
   };
 
@@ -107,19 +80,10 @@ goog.scope(function () {
     return this.platform_;
   };
 
-  /**
-   * @export
-   * @deprecated
-   * @return {string}
-   */
-  UserAgent.prototype.getPlatformVersion = function() {
-    return this.platformVersionString_;
-  };
-
   /**
    * @return {webfont.Version}
    */
-  UserAgent.prototype.getParsedPlatformVersion = function() {
+  UserAgent.prototype.getPlatformVersion = function() {
     return this.platformVersion_;
   };