jekyll-theme-chalk 0.1.1

data/_assets/yarn/webfontloader/src/core/fontwatcher.js

@@ -0,0 +1,171 @@
+goog.provide('webfont.FontWatcher');
+
+goog.require('webfont.FontWatchRunner');
+goog.require('webfont.NativeFontWatchRunner');
+
+/**
+ * @typedef {Object.<string, Array.<string>>}
+ */
+webfont.FontTestStrings;
+
+/**
+ * @constructor
+ * @param {webfont.DomHelper} domHelper
+ * @param {webfont.EventDispatcher} eventDispatcher
+ * @param {number=} opt_timeout
+ */
+webfont.FontWatcher = function(domHelper, eventDispatcher, opt_timeout) {
+  this.domHelper_ = domHelper;
+  this.eventDispatcher_ = eventDispatcher;
+  this.currentlyWatched_ = 0;
+  this.last_ = false;
+  this.success_ = false;
+  this.timeout_ = opt_timeout;
+};
+
+goog.scope(function () {
+  var FontWatcher = webfont.FontWatcher,
+      FontWatchRunner = webfont.FontWatchRunner,
+      NativeFontWatchRunner = webfont.NativeFontWatchRunner;
+
+  /**
+   * @type {null|boolean}
+   */
+  FontWatcher.SHOULD_USE_NATIVE_LOADER = null;
+
+  /**
+   * @return {string}
+   */
+  FontWatcher.getUserAgent = function () {
+    return window.navigator.userAgent;
+  };
+
+  /**
+   * @return {string}
+   */
+  FontWatcher.getVendor = function () {
+    return window.navigator.vendor;
+  };
+
+  /**
+   * Returns true if this browser has support for
+   * the CSS font loading API.
+   *
+   * @return {boolean}
+   */
+  FontWatcher.shouldUseNativeLoader = function () {
+    if (FontWatcher.SHOULD_USE_NATIVE_LOADER === null) {
+      if (!!window.FontFace) {
+        var match = /Gecko.*Firefox\/(\d+)/.exec(FontWatcher.getUserAgent());
+        var safari10Match = /OS X.*Version\/10\..*Safari/.exec(FontWatcher.getUserAgent()) && /Apple/.exec(FontWatcher.getVendor());
+
+        if (match) {
+          FontWatcher.SHOULD_USE_NATIVE_LOADER = parseInt(match[1], 10) > 42;
+        } else if (safari10Match) {
+          FontWatcher.SHOULD_USE_NATIVE_LOADER = false;
+        } else {
+          FontWatcher.SHOULD_USE_NATIVE_LOADER = true;
+        }
+      } else {
+        FontWatcher.SHOULD_USE_NATIVE_LOADER = false;
+      }
+    }
+    return FontWatcher.SHOULD_USE_NATIVE_LOADER;
+  };
+
+  /**
+   * Watches a set of font families.
+   * @param {Array.<webfont.Font>} fonts The fonts to watch.
+   * @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,
+        testStrings = fontTestStrings || {};
+
+    if (length === 0 && last) {
+      this.eventDispatcher_.dispatchInactive();
+      return;
+    }
+
+    this.currentlyWatched_ += fonts.length;
+
+    if (last) {
+      this.last_ = last;
+    }
+
+    var i, fontWatchRunners = [];
+    for (i = 0; i < fonts.length; i++) {
+      var font = fonts[i],
+          testString = testStrings[font.getName()];
+
+      this.eventDispatcher_.dispatchFontLoading(font);
+
+      var fontWatchRunner = null;
+
+      if (FontWatcher.shouldUseNativeLoader()) {
+        fontWatchRunner = new NativeFontWatchRunner(
+            goog.bind(this.fontActive_, this),
+            goog.bind(this.fontInactive_, this),
+            this.domHelper_,
+            font,
+            this.timeout_,
+            testString
+          );
+      } else {
+        fontWatchRunner = new FontWatchRunner(
+          goog.bind(this.fontActive_, this),
+          goog.bind(this.fontInactive_, this),
+          this.domHelper_,
+          font,
+          this.timeout_,
+          metricCompatibleFonts,
+          testString
+        );
+      }
+
+      fontWatchRunners.push(fontWatchRunner);
+    }
+
+    for (i = 0; i < fontWatchRunners.length; i++) {
+      fontWatchRunners[i].start();
+    }
+  };
+
+  /**
+   * Called by a FontWatchRunner when a font has been detected as active.
+   * @param {webfont.Font} font
+   * @private
+   */
+  FontWatcher.prototype.fontActive_ = function(font) {
+    this.eventDispatcher_.dispatchFontActive(font);
+    this.success_ = true;
+    this.decreaseCurrentlyWatched_();
+  };
+
+  /**
+   * Called by a FontWatchRunner when a font has been detected as inactive.
+   * @param {webfont.Font} font
+   * @private
+   */
+  FontWatcher.prototype.fontInactive_ = function(font) {
+    this.eventDispatcher_.dispatchFontInactive(font);
+    this.decreaseCurrentlyWatched_();
+  };
+
+  /**
+   * @private
+   */
+  FontWatcher.prototype.decreaseCurrentlyWatched_ = function() {
+    if (--this.currentlyWatched_ == 0 && this.last_) {
+      if (this.success_) {
+        this.eventDispatcher_.dispatchActive();
+      } else {
+        this.eventDispatcher_.dispatchInactive();
+      }
+    }
+  };
+});

data/_assets/yarn/webfontloader/src/core/fontwatchrunner.js

@@ -0,0 +1,249 @@
+goog.provide('webfont.FontWatchRunner');
+
+goog.require('webfont.Font');
+goog.require('webfont.FontRuler');
+
+/**
+ * @constructor
+ * @param {function(webfont.Font)} activeCallback
+ * @param {function(webfont.Font)} inactiveCallback
+ * @param {webfont.DomHelper} domHelper
+ * @param {webfont.Font} font
+ * @param {number=} opt_timeout
+ * @param {Object.<string, boolean>=} opt_metricCompatibleFonts
+ * @param {string=} opt_fontTestString
+ */
+webfont.FontWatchRunner = function(activeCallback, inactiveCallback, domHelper,
+    font, opt_timeout, opt_metricCompatibleFonts, opt_fontTestString) {
+  this.activeCallback_ = activeCallback;
+  this.inactiveCallback_ = inactiveCallback;
+  this.domHelper_ = domHelper;
+  this.font_ = font;
+  this.fontTestString_ = opt_fontTestString || webfont.FontWatchRunner.DEFAULT_TEST_STRING;
+  this.lastResortWidths_ = {};
+  this.timeout_ = opt_timeout || 3000;
+
+  this.metricCompatibleFonts_ = opt_metricCompatibleFonts || null;
+
+  this.fontRulerA_ = null;
+  this.fontRulerB_ = null;
+  this.lastResortRulerA_ = null;
+  this.lastResortRulerB_ = null;
+
+  this.setupRulers_();
+};
+
+/**
+ * @enum {string}
+ * @const
+ */
+webfont.FontWatchRunner.LastResortFonts = {
+  SERIF: 'serif',
+  SANS_SERIF: 'sans-serif'
+};
+
+/**
+ * Default test string. Characters are chosen so that their widths vary a lot
+ * between the fonts in the default stacks. We want each fallback stack
+ * to always start out at a different width than the other.
+ * @type {string}
+ * @const
+ */
+webfont.FontWatchRunner.DEFAULT_TEST_STRING = 'BESbswy';
+
+goog.scope(function () {
+  var FontWatchRunner = webfont.FontWatchRunner,
+      Font = webfont.Font,
+      FontRuler = webfont.FontRuler;
+
+  /**
+   * @type {null|boolean}
+   */
+  FontWatchRunner.HAS_WEBKIT_FALLBACK_BUG = null;
+
+  /**
+   * @return {string}
+   */
+  FontWatchRunner.getUserAgent = function () {
+    return window.navigator.userAgent;
+  };
+
+  /**
+   * Returns true if this browser is WebKit and it has the fallback bug
+   * which is present in WebKit 536.11 and earlier.
+   *
+   * @return {boolean}
+   */
+  FontWatchRunner.hasWebKitFallbackBug = function () {
+    if (FontWatchRunner.HAS_WEBKIT_FALLBACK_BUG === null) {
+      var match = /AppleWebKit\/([0-9]+)(?:\.([0-9]+))/.exec(FontWatchRunner.getUserAgent());
+
+      FontWatchRunner.HAS_WEBKIT_FALLBACK_BUG = !!match &&
+                                          (parseInt(match[1], 10) < 536 ||
+                                           (parseInt(match[1], 10) === 536 &&
+                                            parseInt(match[2], 10) <= 11));
+    }
+    return FontWatchRunner.HAS_WEBKIT_FALLBACK_BUG;
+  };
+
+  /**
+   * @private
+   */
+  FontWatchRunner.prototype.setupRulers_ = function() {
+    this.fontRulerA_ = new FontRuler(this.domHelper_, this.fontTestString_);
+    this.fontRulerB_ = new FontRuler(this.domHelper_, this.fontTestString_);
+    this.lastResortRulerA_ = new FontRuler(this.domHelper_, this.fontTestString_);
+    this.lastResortRulerB_ = new FontRuler(this.domHelper_, this.fontTestString_);
+
+    this.fontRulerA_.setFont(new Font(this.font_.getName() + ',' + FontWatchRunner.LastResortFonts.SERIF, this.font_.getVariation()));
+    this.fontRulerB_.setFont(new Font(this.font_.getName() + ',' + FontWatchRunner.LastResortFonts.SANS_SERIF, this.font_.getVariation()));
+    this.lastResortRulerA_.setFont(new Font(FontWatchRunner.LastResortFonts.SERIF, this.font_.getVariation()));
+    this.lastResortRulerB_.setFont(new Font(FontWatchRunner.LastResortFonts.SANS_SERIF, this.font_.getVariation()));
+
+    this.fontRulerA_.insert();
+    this.fontRulerB_.insert();
+    this.lastResortRulerA_.insert();
+    this.lastResortRulerB_.insert();
+  };
+
+  FontWatchRunner.prototype.start = function() {
+    this.lastResortWidths_[FontWatchRunner.LastResortFonts.SERIF] = this.lastResortRulerA_.getWidth();
+    this.lastResortWidths_[FontWatchRunner.LastResortFonts.SANS_SERIF] = this.lastResortRulerB_.getWidth();
+
+    this.started_ = goog.now();
+
+    this.check_();
+  };
+
+  /**
+   * Returns true if the given width matches the generic font family width.
+   *
+   * @private
+   * @param {number} width
+   * @param {string} lastResortFont
+   * @return {boolean}
+   */
+  FontWatchRunner.prototype.widthMatches_ = function(width, lastResortFont) {
+    return width === this.lastResortWidths_[lastResortFont];
+  };
+
+  /**
+   * Return true if the given widths match any of the generic font family
+   * widths.
+   *
+   * @private
+   * @param {number} a
+   * @param {number} b
+   * @return {boolean}
+   */
+  FontWatchRunner.prototype.widthsMatchLastResortWidths_ = function(a, b) {
+    for (var font in FontWatchRunner.LastResortFonts) {
+      if (FontWatchRunner.LastResortFonts.hasOwnProperty(font)) {
+        if (this.widthMatches_(a, FontWatchRunner.LastResortFonts[font]) &&
+            this.widthMatches_(b, FontWatchRunner.LastResortFonts[font])) {
+          return true;
+        }
+      }
+    }
+    return false;
+  };
+
+  /**
+   * @private
+   * Returns true if the loading has timed out.
+   * @return {boolean}
+   */
+  FontWatchRunner.prototype.hasTimedOut_ = function() {
+    return goog.now() - this.started_ >= this.timeout_;
+  };
+
+  /**
+   * Returns true if both fonts match the normal fallback fonts.
+   *
+   * @private
+   * @param {number} a
+   * @param {number} b
+   * @return {boolean}
+   */
+  FontWatchRunner.prototype.isFallbackFont_ = function (a, b) {
+    return this.widthMatches_(a, FontWatchRunner.LastResortFonts.SERIF) &&
+           this.widthMatches_(b, FontWatchRunner.LastResortFonts.SANS_SERIF);
+  };
+
+  /**
+   * Returns true if the WebKit bug is present and both widths match a last resort font.
+   *
+   * @private
+   * @param {number} a
+   * @param {number} b
+   * @return {boolean}
+   */
+  FontWatchRunner.prototype.isLastResortFont_ = function (a, b) {
+    return FontWatchRunner.hasWebKitFallbackBug() && this.widthsMatchLastResortWidths_(a, b);
+  };
+
+  /**
+   * Returns true if the current font is metric compatible. Also returns true
+   * if we do not have a list of metric compatible fonts.
+   *
+   * @private
+   * @return {boolean}
+   */
+  FontWatchRunner.prototype.isMetricCompatibleFont_ = function () {
+    return this.metricCompatibleFonts_ === null || this.metricCompatibleFonts_.hasOwnProperty(this.font_.getName());
+  };
+
+  /**
+   * Checks the width of the two spans against their original widths during each
+   * async loop. If the width of one of the spans is different than the original
+   * width, then we know that the font is rendering and finish with the active
+   * callback. If we wait more than 5 seconds and nothing has changed, we finish
+   * with the inactive callback.
+   *
+   * @private
+   */
+  FontWatchRunner.prototype.check_ = function() {
+    var widthA = this.fontRulerA_.getWidth();
+    var widthB = this.fontRulerB_.getWidth();
+
+    if (this.isFallbackFont_(widthA, widthB) || this.isLastResortFont_(widthA, widthB)) {
+      if (this.hasTimedOut_()) {
+        if (this.isLastResortFont_(widthA, widthB) && this.isMetricCompatibleFont_()) {
+          this.finish_(this.activeCallback_);
+        } else {
+          this.finish_(this.inactiveCallback_);
+        }
+     } else {
+        this.asyncCheck_();
+      }
+    } else {
+      this.finish_(this.activeCallback_);
+    }
+  };
+
+  /**
+   * @private
+   */
+  FontWatchRunner.prototype.asyncCheck_ = function() {
+    setTimeout(goog.bind(function () {
+      this.check_();
+    }, this), 50);
+  };
+
+  /**
+   * @private
+   * @param {function(webfont.Font)} callback
+   */
+  FontWatchRunner.prototype.finish_ = function(callback) {
+    // Remove elements and trigger callback (which adds active/inactive class) asynchronously to avoid reflow chain if
+    // several fonts are finished loading right after each other
+    setTimeout(goog.bind(function () {
+      this.fontRulerA_.remove();
+      this.fontRulerB_.remove();
+      this.lastResortRulerA_.remove();
+      this.lastResortRulerB_.remove();
+      callback(this.font_);
+    }, this), 0);
+  };
+
+});

data/_assets/yarn/webfontloader/src/core/initialize.js

@@ -0,0 +1,97 @@
+goog.provide('webfont');
+
+goog.require('webfont.WebFont');
+
+goog.require('webfont.modules.Typekit');
+goog.require('webfont.modules.Fontdeck');
+goog.require('webfont.modules.Monotype');
+goog.require('webfont.modules.Custom');
+goog.require('webfont.modules.google.GoogleFontApi');
+
+/**
+ * @define {boolean}
+ */
+var INCLUDE_CUSTOM_MODULE = false;
+
+/**
+ * @define {boolean}
+ */
+var INCLUDE_FONTDECK_MODULE = false;
+
+/**
+ * @define {boolean}
+ */
+var INCLUDE_MONOTYPE_MODULE = false;
+
+/**
+ * @define {boolean}
+ */
+var INCLUDE_TYPEKIT_MODULE = false;
+
+/**
+ * @define {boolean}
+ */
+var INCLUDE_GOOGLE_MODULE = false;
+
+/**
+ * @define {string}
+ */
+var WEBFONT = 'WebFont';
+
+/**
+ * @define {string}
+ */
+var WEBFONT_CONFIG = 'WebFontConfig';
+
+/**
+ * @type {webfont.WebFont}
+ */
+var webFontLoader = new webfont.WebFont(window);
+
+if (INCLUDE_CUSTOM_MODULE) {
+  webFontLoader.addModule(webfont.modules.Custom.NAME, function (configuration, domHelper) {
+    return new webfont.modules.Custom(domHelper, configuration);
+  });
+}
+
+if (INCLUDE_FONTDECK_MODULE) {
+  webFontLoader.addModule(webfont.modules.Fontdeck.NAME, function (configuration, domHelper) {
+    return new webfont.modules.Fontdeck(domHelper, configuration);
+  });
+}
+
+if (INCLUDE_MONOTYPE_MODULE) {
+  webFontLoader.addModule(webfont.modules.Monotype.NAME, function (configuration, domHelper) {
+    return new webfont.modules.Monotype(domHelper, configuration);
+  });
+}
+
+if (INCLUDE_TYPEKIT_MODULE) {
+  webFontLoader.addModule(webfont.modules.Typekit.NAME, function (configuration, domHelper) {
+    return new webfont.modules.Typekit(domHelper, configuration);
+  });
+}
+
+if (INCLUDE_GOOGLE_MODULE) {
+  webFontLoader.addModule(webfont.modules.google.GoogleFontApi.NAME, function (configuration, domHelper) {
+    return new webfont.modules.google.GoogleFontApi(domHelper, configuration);
+  });
+}
+
+var exports = {
+  'load': goog.bind(webFontLoader.load, webFontLoader)
+};
+
+if (typeof define === "function" && define.amd) {
+  define(function () {
+    return exports;
+  });
+} else if (typeof module !== "undefined" && module.exports) {
+  module.exports = exports;
+} else {
+  window[WEBFONT] = exports;
+
+  if (window[WEBFONT_CONFIG]) {
+    webFontLoader.load(window[WEBFONT_CONFIG]);
+  }
+}