jekyll-theme-chalk 0.1.1

data/_assets/yarn/turbolinks/src/turbolinks/history.coffee

@@ -0,0 +1,48 @@
+class Turbolinks.History
+  constructor: (@delegate) ->
+
+  start: ->
+    unless @started
+      addEventListener("popstate", @onPopState, false)
+      addEventListener("load", @onPageLoad, false)
+      @started = true
+
+  stop: ->
+    if @started
+      removeEventListener("popstate", @onPopState, false)
+      removeEventListener("load", @onPageLoad, false)
+      @started = false
+
+  push: (location, restorationIdentifier) ->
+    location = Turbolinks.Location.wrap(location)
+    @update("push", location, restorationIdentifier)
+
+  replace: (location, restorationIdentifier) ->
+    location = Turbolinks.Location.wrap(location)
+    @update("replace", location, restorationIdentifier)
+
+  # Event handlers
+
+  onPopState: (event) =>
+    if @shouldHandlePopState()
+      if turbolinks = event.state?.turbolinks
+        location = Turbolinks.Location.wrap(window.location)
+        restorationIdentifier = turbolinks.restorationIdentifier
+        @delegate.historyPoppedToLocationWithRestorationIdentifier(location, restorationIdentifier)
+
+  onPageLoad: (event) =>
+    Turbolinks.defer =>
+      @pageLoaded = true
+
+  # Private
+
+  shouldHandlePopState: ->
+    # Safari dispatches a popstate event after window's load event, ignore it
+    @pageIsLoaded()
+
+  pageIsLoaded: ->
+    @pageLoaded or document.readyState is "complete"
+
+  update: (method, location, restorationIdentifier) ->
+    state = turbolinks: {restorationIdentifier}
+    history[method + "State"](state, null, location)

data/_assets/yarn/turbolinks/src/turbolinks/http_request.coffee

@@ -0,0 +1,88 @@
+class Turbolinks.HttpRequest
+  @NETWORK_FAILURE = 0
+  @TIMEOUT_FAILURE = -1
+
+  @timeout = 60
+
+  constructor: (@delegate, location, referrer) ->
+    @url = Turbolinks.Location.wrap(location).requestURL
+    @referrer = Turbolinks.Location.wrap(referrer).absoluteURL
+    @createXHR()
+
+  send: ->
+    if @xhr and not @sent
+      @notifyApplicationBeforeRequestStart()
+      @setProgress(0)
+      @xhr.send()
+      @sent = true
+      @delegate.requestStarted?()
+
+  cancel: ->
+    if @xhr and @sent
+      @xhr.abort()
+
+  # XMLHttpRequest events
+
+  requestProgressed: (event) =>
+    if event.lengthComputable
+      @setProgress(event.loaded / event.total)
+
+  requestLoaded: =>
+    @endRequest =>
+      if 200 <= @xhr.status < 300
+        @delegate.requestCompletedWithResponse(@xhr.responseText, @xhr.getResponseHeader("Turbolinks-Location"))
+      else
+        @failed = true
+        @delegate.requestFailedWithStatusCode(@xhr.status, @xhr.responseText)
+
+  requestFailed: =>
+    @endRequest =>
+      @failed = true
+      @delegate.requestFailedWithStatusCode(@constructor.NETWORK_FAILURE)
+
+  requestTimedOut: =>
+    @endRequest =>
+      @failed = true
+      @delegate.requestFailedWithStatusCode(@constructor.TIMEOUT_FAILURE)
+
+  requestCanceled: =>
+    @endRequest()
+
+
+  # Application events
+
+  notifyApplicationBeforeRequestStart: ->
+    Turbolinks.dispatch("turbolinks:request-start", data: { url: @url, xhr: @xhr })
+
+  notifyApplicationAfterRequestEnd: ->
+    Turbolinks.dispatch("turbolinks:request-end", data: { url: @url, xhr: @xhr })
+
+  # Private
+
+  createXHR: ->
+    @xhr = new XMLHttpRequest
+    @xhr.open("GET", @url, true)
+    @xhr.timeout = @constructor.timeout * 1000
+    @xhr.setRequestHeader("Accept", "text/html, application/xhtml+xml")
+    @xhr.setRequestHeader("Turbolinks-Referrer", @referrer)
+    @xhr.onprogress = @requestProgressed
+    @xhr.onload = @requestLoaded
+    @xhr.onerror = @requestFailed
+    @xhr.ontimeout = @requestTimedOut
+    @xhr.onabort = @requestCanceled
+
+  endRequest: (callback) ->
+    if @xhr
+      @notifyApplicationAfterRequestEnd()
+      callback?.call(this)
+      @destroy()
+
+  setProgress: (progress) ->
+    @progress = progress
+    @delegate.requestProgressed?(@progress)
+
+  destroy: ->
+    @setProgress(1)
+    @delegate.requestFinished?()
+    @delegate = null
+    @xhr = null

data/_assets/yarn/turbolinks/src/turbolinks/index.coffee

@@ -0,0 +1,18 @@
+#= require ./BANNER
+#= export Turbolinks
+#= require_self
+#= require ./helpers
+#= require ./controller
+#= require ./start
+
+@Turbolinks =
+  supported: do ->
+    window.history.pushState? and
+      window.requestAnimationFrame? and
+      window.addEventListener?
+
+  visit: (location, options) ->
+    Turbolinks.controller.visit(location, options)
+
+  clearCache: ->
+    Turbolinks.controller.clearCache()

data/_assets/yarn/turbolinks/src/turbolinks/location.coffee

@@ -0,0 +1,70 @@
+class Turbolinks.Location
+  @wrap: (value) ->
+    if value instanceof this
+      value
+    else
+      new this value
+
+  constructor: (url = "") ->
+    linkWithAnchor = document.createElement("a")
+    linkWithAnchor.href = url.toString()
+
+    @absoluteURL = linkWithAnchor.href
+
+    anchorLength = linkWithAnchor.hash.length
+    if anchorLength < 2
+      @requestURL = @absoluteURL
+    else
+      @requestURL = @absoluteURL.slice(0, -anchorLength)
+      @anchor = linkWithAnchor.hash.slice(1)
+
+  getOrigin: ->
+    @absoluteURL.split("/", 3).join("/")
+
+  getPath: ->
+    @absoluteURL.match(/\/\/[^/]*(\/[^?;]*)/)?[1] ? "/"
+
+  getPathComponents: ->
+    @getPath().split("/").slice(1)
+
+  getLastPathComponent: ->
+    @getPathComponents().slice(-1)[0]
+
+  getExtension: ->
+    @getLastPathComponent().match(/\.[^.]*$/)?[0] ? ""
+
+  isHTML: ->
+    @getExtension().match(/^(?:|\.(?:htm|html|xhtml))$/)
+
+  isPrefixedBy: (location) ->
+    prefixURL = getPrefixURL(location)
+    @isEqualTo(location) or stringStartsWith(@absoluteURL, prefixURL)
+
+  isEqualTo: (location) ->
+    @absoluteURL is location?.absoluteURL
+
+  toCacheKey: ->
+    @requestURL
+
+  toJSON: ->
+    @absoluteURL
+
+  toString: ->
+    @absoluteURL
+
+  valueOf: ->
+    @absoluteURL
+
+  # Private
+
+  getPrefixURL = (location) ->
+    addTrailingSlash(location.getOrigin() + location.getPath())
+
+  addTrailingSlash = (url) ->
+    if stringEndsWith(url, "/") then url else url + "/"
+
+  stringStartsWith = (string, prefix) ->
+    string.slice(0, prefix.length) is prefix
+
+  stringEndsWith = (string, suffix) ->
+    string.slice(-suffix.length) is suffix

data/_assets/yarn/turbolinks/src/turbolinks/progress_bar.coffee

@@ -0,0 +1,83 @@
+class Turbolinks.ProgressBar
+  ANIMATION_DURATION = 300
+
+  @defaultCSS: """
+    .turbolinks-progress-bar {
+      position: fixed;
+      display: block;
+      top: 0;
+      left: 0;
+      height: 3px;
+      background: #0076ff;
+      z-index: 9999;
+      transition: width #{ANIMATION_DURATION}ms ease-out, opacity #{ANIMATION_DURATION / 2}ms #{ANIMATION_DURATION / 2}ms ease-in;
+      transform: translate3d(0, 0, 0);
+    }
+  """
+
+  constructor: ->
+    @stylesheetElement = @createStylesheetElement()
+    @progressElement = @createProgressElement()
+
+  show: ->
+    unless @visible
+      @visible = true
+      @installStylesheetElement()
+      @installProgressElement()
+      @startTrickling()
+
+  hide: ->
+    if @visible and not @hiding
+      @hiding = true
+      @fadeProgressElement =>
+        @uninstallProgressElement()
+        @stopTrickling()
+        @visible = false
+        @hiding = false
+
+  setValue: (@value) ->
+    @refresh()
+
+  # Private
+
+  installStylesheetElement: ->
+    document.head.insertBefore(@stylesheetElement, document.head.firstChild)
+
+  installProgressElement: ->
+    @progressElement.style.width = 0
+    @progressElement.style.opacity = 1
+    document.documentElement.insertBefore(@progressElement, document.body)
+    @refresh()
+
+  fadeProgressElement: (callback) ->
+    @progressElement.style.opacity = 0
+    setTimeout(callback, ANIMATION_DURATION * 1.5)
+
+  uninstallProgressElement: ->
+    if @progressElement.parentNode
+      document.documentElement.removeChild(@progressElement)
+
+  startTrickling: ->
+    @trickleInterval ?= setInterval(@trickle, ANIMATION_DURATION)
+
+  stopTrickling: ->
+    clearInterval(@trickleInterval)
+    @trickleInterval = null
+
+  trickle: =>
+    @setValue(@value + Math.random() / 100)
+
+  refresh: ->
+    requestAnimationFrame =>
+      @progressElement.style.width = "#{10 + (@value * 90)}%"
+
+  createStylesheetElement: ->
+    element = document.createElement("style")
+    element.type = "text/css"
+    element.textContent = @constructor.defaultCSS
+    element
+
+  createProgressElement: ->
+    element = document.createElement("div")
+    element.className = "turbolinks-progress-bar"
+    element

data/_assets/yarn/turbolinks/src/turbolinks/renderer.coffee

@@ -0,0 +1,27 @@
+class Turbolinks.Renderer
+  @render: (delegate, callback, args...) ->
+    renderer = new this args...
+    renderer.delegate = delegate
+    renderer.render(callback)
+    renderer
+
+  renderView: (callback) ->
+    @delegate.viewWillRender(@newBody)
+    callback()
+    @delegate.viewRendered(@newBody)
+
+  invalidateView: ->
+    @delegate.viewInvalidated()
+
+  createScriptElement: (element) ->
+    if element.getAttribute("data-turbolinks-eval") is "false"
+      element
+    else
+      createdScriptElement = document.createElement("script")
+      createdScriptElement.textContent = element.textContent
+      copyElementAttributes(createdScriptElement, element)
+      createdScriptElement
+
+  copyElementAttributes = (destinationElement, sourceElement) ->
+    for {name, value} in sourceElement.attributes
+      destinationElement.setAttribute(name, value)

data/_assets/yarn/turbolinks/src/turbolinks/scroll_manager.coffee

@@ -0,0 +1,28 @@
+class Turbolinks.ScrollManager
+  constructor: (@delegate) ->
+    @onScroll = Turbolinks.throttle(@onScroll)
+
+  start: ->
+    unless @started
+      addEventListener("scroll", @onScroll, false)
+      @onScroll()
+      @started = true
+
+  stop: ->
+    if @started
+      removeEventListener("scroll", @onScroll, false)
+      @started = false
+
+  scrollToElement: (element) ->
+    element.scrollIntoView()
+
+  scrollToPosition: ({x, y}) ->
+    window.scrollTo(x, y)
+
+  onScroll: (event) =>
+    @updatePosition(x: window.pageXOffset, y: window.pageYOffset)
+
+  # Private
+
+  updatePosition: (@position) ->
+    @delegate?.scrollPositionChanged(@position)

data/_assets/yarn/turbolinks/src/turbolinks/snapshot.coffee

@@ -0,0 +1,47 @@
+class Turbolinks.Snapshot
+  @wrap: (value) ->
+    if value instanceof this
+      value
+    else
+      @fromHTML(value)
+
+  @fromHTML: (html) ->
+    element = document.createElement("html")
+    element.innerHTML = html
+    @fromElement(element)
+
+  @fromElement: (element) ->
+    new this
+      head: element.querySelector("head")
+      body: element.querySelector("body")
+
+  constructor: ({head, body}) ->
+    @head = head ? document.createElement("head")
+    @body = body ? document.createElement("body")
+
+  clone: ->
+    new Snapshot
+      head: @head.cloneNode(true)
+      body: @body.cloneNode(true)
+
+  getRootLocation: ->
+    root = @getSetting("root") ? "/"
+    new Turbolinks.Location root
+
+  getCacheControlValue: ->
+    @getSetting("cache-control")
+
+  hasAnchor: (anchor) ->
+    try @body.querySelector("[id='#{anchor}']")?
+
+  isPreviewable: ->
+    @getCacheControlValue() isnt "no-preview"
+
+  isCacheable: ->
+    @getCacheControlValue() isnt "no-cache"
+
+  # Private
+
+  getSetting: (name) ->
+    [..., element] = @head.querySelectorAll("meta[name='turbolinks-#{name}']")
+    element?.getAttribute("content")

data/_assets/yarn/turbolinks/src/turbolinks/snapshot_cache.coffee

@@ -0,0 +1,43 @@
+class Turbolinks.SnapshotCache
+  constructor: (@size) ->
+    @keys = []
+    @snapshots = {}
+
+  has: (location) ->
+    key = keyForLocation(location)
+    key of @snapshots
+
+  get: (location) ->
+    return unless @has(location)
+    snapshot = @read(location)
+    @touch(location)
+    snapshot
+
+  put: (location, snapshot) ->
+    @write(location, snapshot)
+    @touch(location)
+    snapshot
+
+  # Private
+
+  read: (location) ->
+    key = keyForLocation(location)
+    @snapshots[key]
+
+  write: (location, snapshot) ->
+    key = keyForLocation(location)
+    @snapshots[key] = snapshot
+
+  touch: (location) ->
+    key = keyForLocation(location)
+    index = @keys.indexOf(key)
+    @keys.splice(index, 1) if index > -1
+    @keys.unshift(key)
+    @trim()
+
+  trim: ->
+    for key in @keys.splice(@size)
+      delete @snapshots[key]
+
+  keyForLocation = (location) ->
+    Turbolinks.Location.wrap(location).toCacheKey()