jekyll-theme-chalk 0.1.1

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

@@ -0,0 +1,195 @@
+goog.provide('webfont.EventDispatcher');
+
+goog.require('webfont.CssClassName');
+
+/**
+ * A class to dispatch events and manage the event class names on an html
+ * element that represent the current state of fonts on the page. Active class
+ * names always overwrite inactive class names of the same type, while loading
+ * class names may be present whenever a font is loading (regardless of if an
+ * associated active or inactive class name is also present).
+ *
+ * @param {webfont.DomHelper} domHelper
+ * @param {Object} config
+ * @constructor
+ */
+webfont.EventDispatcher = function(domHelper, config) {
+  this.domHelper_ = domHelper;
+  this.htmlElement_ = domHelper.getLoadWindow().document.documentElement;
+  this.callbacks_ = config;
+  this.namespace_ = webfont.EventDispatcher.DEFAULT_NAMESPACE;
+  this.cssClassName_ = new webfont.CssClassName('-');
+  this.dispatchEvents_ = config['events'] !== false;
+  this.setClasses_ = config['classes'] !== false;
+};
+
+/**
+ * @const
+ * @type {string}
+ */
+webfont.EventDispatcher.DEFAULT_NAMESPACE = 'wf';
+
+/**
+ * @const
+ * @type {string}
+ */
+webfont.EventDispatcher.LOADING = 'loading';
+
+/**
+ * @const
+ * @type {string}
+ */
+webfont.EventDispatcher.ACTIVE = 'active';
+
+/**
+ * @const
+ * @type {string}
+ */
+webfont.EventDispatcher.INACTIVE = 'inactive';
+
+/**
+ * @const
+ * @type {string}
+ */
+webfont.EventDispatcher.FONT = 'font';
+
+goog.scope(function () {
+  var EventDispatcher = webfont.EventDispatcher;
+
+  /**
+   * Dispatch the loading event and append the loading class name.
+   */
+  EventDispatcher.prototype.dispatchLoading = function() {
+    if (this.setClasses_) {
+      this.domHelper_.updateClassName(this.htmlElement_,
+        [
+          this.cssClassName_.build(this.namespace_, webfont.EventDispatcher.LOADING)
+        ]
+      );
+    }
+
+    this.dispatch_(webfont.EventDispatcher.LOADING);
+  };
+
+  /**
+   * Dispatch the font loading event and append the font loading class name.
+   * @param {webfont.Font} font
+   */
+  EventDispatcher.prototype.dispatchFontLoading = function(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);
+  };
+
+  /**
+   * Dispatch the font active event, remove the font loading class name, remove
+   * the font inactive class name, and append the font active class name.
+   * @param {webfont.Font} font
+   */
+  EventDispatcher.prototype.dispatchFontActive = function(font) {
+    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);
+  };
+
+  /**
+   * Dispatch the font inactive event, remove the font loading class name, and
+   * append the font inactive class name (unless the font active class name is
+   * already present).
+   * @param {webfont.Font} font
+   */
+  EventDispatcher.prototype.dispatchFontInactive = function(font) {
+    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));
+      }
+
+      this.domHelper_.updateClassName(this.htmlElement_, add, remove);
+    }
+
+    this.dispatch_(webfont.EventDispatcher.FONT + webfont.EventDispatcher.INACTIVE, font);
+  };
+
+  /**
+   * Dispatch the inactive event, remove the loading class name, and append the
+   * inactive class name (unless the active class name is already present).
+   */
+  EventDispatcher.prototype.dispatchInactive = function() {
+    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));
+      }
+
+      this.domHelper_.updateClassName(this.htmlElement_, add, remove);
+    }
+
+    this.dispatch_(webfont.EventDispatcher.INACTIVE);
+  };
+
+  /**
+   * Dispatch the active event, remove the loading class name, remove the inactive
+   * class name, and append the active class name.
+   */
+  EventDispatcher.prototype.dispatchActive = function() {
+    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);
+  };
+
+  /**
+   * @param {string} event
+   * @param {webfont.Font=} opt_font
+   */
+  EventDispatcher.prototype.dispatch_ = function(event, opt_font) {
+    if (this.dispatchEvents_ && this.callbacks_[event]) {
+      if (opt_font) {
+        this.callbacks_[event](opt_font.getName(), opt_font.getVariation());
+      } else {
+        this.callbacks_[event]();
+      }
+    }
+  };
+});

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

@@ -0,0 +1,140 @@
+goog.provide('webfont.Font');
+
+/**
+ * This class is an abstraction for a single font or typeface.
+ * It contains the font name and the variation (i.e. style
+ * and weight.) A collection Font instances can represent a
+ * font family.
+ *
+ * @constructor
+ * @param {string} name The font family name
+ * @param {string=} opt_variation A font variation description
+ */
+webfont.Font = function (name, opt_variation) {
+  this.name_ = name;
+  this.weight_ = 4;
+  this.style_ = 'n'
+
+  var variation = opt_variation || 'n4',
+      match = variation.match(/^([nio])([1-9])$/i);
+
+  if (match) {
+    this.style_ = match[1];
+    this.weight_ = parseInt(match[2], 10);
+  }
+};
+
+goog.scope(function () {
+  var Font = webfont.Font;
+
+  /**
+   * @return {string}
+   */
+  Font.prototype.getName = function () {
+    return this.name_;
+  };
+
+  /**
+   * @return {string}
+   */
+  Font.prototype.getCssName = function () {
+    return this.quote_(this.name_);
+  };
+
+  /**
+   * Returns a CSS string representation of the font that
+   * can be used as the CSS font property shorthand.
+   *
+   * @return {string}
+   */
+  Font.prototype.toCssString = function () {
+    return this.getCssStyle() + ' ' + this.getCssWeight() + ' 300px ' + this.getCssName();
+  };
+
+  /**
+   * @private
+   * @param {string} name
+   * @return {string}
+   */
+  Font.prototype.quote_ = function (name) {
+    var quoted = [];
+    var split = name.split(/,\s*/);
+    for (var i = 0; i < split.length; i++) {
+      var part = split[i].replace(/['"]/g, '');
+      if (part.indexOf(' ') == -1 && !(/^\d/.test(part))) {
+        quoted.push(part);
+      } else {
+        quoted.push("'" + part + "'");
+      }
+    }
+    return quoted.join(',');
+  };
+
+  /**
+   * @return {string}
+   */
+  Font.prototype.getVariation = function () {
+    return this.style_ + this.weight_;
+  };
+
+  /**
+   * @return {string}
+   */
+  Font.prototype.getCssVariation = function () {
+    return 'font-style:' + this.getCssStyle() + ';font-weight:' + this.getCssWeight() + ';';
+  };
+
+  /**
+   * @return {string}
+   */
+  Font.prototype.getCssWeight = function () {
+    return this.weight_ + '00';
+  };
+
+  /**
+   * @return {string}
+   */
+  Font.prototype.getCssStyle = function () {
+    var style = 'normal';
+
+    if (this.style_ === 'o') {
+      style = 'oblique';
+    } else if (this.style_ === 'i') {
+      style = 'italic';
+    }
+
+    return style;
+  };
+
+  /**
+   * Parses a CSS font declaration and returns a font
+   * variation description.
+   *
+   * @param {string} css
+   * @return {string}
+   */
+  Font.parseCssVariation = function (css) {
+    var weight = 4,
+        style = 'n',
+        m = null;
+
+    if (css) {
+      m = css.match(/(normal|oblique|italic)/i);
+
+      if (m && m[1]) {
+        style = m[1].substr(0, 1).toLowerCase();
+      }
+
+      m = css.match(/([1-9]00|normal|bold)/i);
+
+      if (m && m[1]) {
+        if (/bold/i.test(m[1])) {
+          weight = 7;
+        } else if (/[1-9]00/.test(m[1])) {
+          weight = parseInt(m[1].substr(0, 1), 10);
+        }
+      }
+    }
+    return style + weight;
+  }
+});

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

@@ -0,0 +1,16 @@
+goog.provide('webfont.FontModule');
+
+/**
+ * @interface
+ */
+webfont.FontModule = function () {};
+
+goog.scope(function () {
+  var FontModule = webfont.FontModule;
+
+  /**
+   * @param {function(Array.<webfont.Font>,  webfont.FontTestStrings=, Object.<string, boolean>=)} onReady
+   */
+  FontModule.prototype.load = function (onReady) {};
+});
+

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

@@ -0,0 +1,47 @@
+goog.provide('webfont.FontModuleLoader');
+goog.provide('webfont.FontModuleFactory');
+
+/** @typedef {function(Object, webfont.DomHelper): webfont.FontModule} */
+webfont.FontModuleFactory;
+
+/**
+ * @constructor
+ */
+webfont.FontModuleLoader = function() {
+  /**
+   * @type {Object.<string, webfont.FontModuleFactory>}
+   */
+  this.modules_ = {};
+};
+
+goog.scope(function () {
+  var FontModuleLoader = webfont.FontModuleLoader;
+
+  /**
+   * @param {string} name
+   * @param {webfont.FontModuleFactory} factory
+   */
+  FontModuleLoader.prototype.addModuleFactory = function(name, factory) {
+    this.modules_[name] = factory;
+  };
+
+  /**
+   * @param {Object} configuration
+   * @param {webfont.DomHelper} domHelper
+   * @return {Array.<webfont.FontModule>}
+   */
+  FontModuleLoader.prototype.getModules = function(configuration, domHelper) {
+    var modules = [];
+
+    for (var key in configuration) {
+      if (configuration.hasOwnProperty(key)) {
+        var moduleFactory = this.modules_[key];
+
+        if (moduleFactory) {
+          modules.push(moduleFactory(configuration[key], domHelper));
+        }
+      }
+    }
+    return modules;
+  };
+});

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

@@ -0,0 +1,60 @@
+goog.provide('webfont.FontRuler');
+
+/**
+ * An element that can be used to measure the metrics
+ * of a given font and string.
+ * @constructor
+ * @param {webfont.DomHelper} domHelper
+ * @param {string} fontTestString
+ */
+webfont.FontRuler = function (domHelper, fontTestString) {
+  this.domHelper_ = domHelper;
+  this.fontTestString_ = fontTestString;
+  this.el_ = this.domHelper_.createElement('span', {
+    "aria-hidden": "true"
+  }, this.fontTestString_);
+};
+
+goog.scope(function () {
+  var FontRuler = webfont.FontRuler;
+
+  /**
+   * @param {webfont.Font} font
+   */
+  FontRuler.prototype.setFont = function(font) {
+    this.domHelper_.setStyle(this.el_, this.computeStyleString_(font));
+  };
+
+  /**
+   * Inserts the ruler into the DOM.
+   */
+  FontRuler.prototype.insert = function() {
+    this.domHelper_.insertInto('body', this.el_);
+  };
+
+  /**
+   * @private
+   * @param {webfont.Font} font
+   * @return {string}
+   */
+  FontRuler.prototype.computeStyleString_ = function(font) {
+    return "display:block;position:absolute;top:-9999px;left:-9999px;" +
+           "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();
+  };
+
+  /**
+   * @return {number}
+   */
+  FontRuler.prototype.getWidth = function() {
+    return this.el_.offsetWidth;
+  };
+
+  /**
+   * Removes the ruler element from the DOM.
+   */
+  FontRuler.prototype.remove = function() {
+    this.domHelper_.removeElement(this.el_);
+  };
+});