unpoly-rails 0.61.0 → 2.0.0.pre.rc3

data/lib/assets/javascripts/unpoly/classes/extract_cascade.coffee

@@ -1,86 +0,0 @@
-u = up.util
-
-class up.ExtractCascade
-
-  constructor: (selectorOrElement, options) ->
-    @options = u.options(options, humanizedTarget: 'selector', layer: 'auto')
-    @options.transition ?= @options.animation
-    @options.hungry ?= true
-
-    @candidates = @buildCandidates(selectorOrElement)
-    @plans = u.map @candidates, (candidate, i) =>
-      planOptions = u.copy(@options)
-      if i > 0
-        # If we're using a fallback (any candidate that's not the first),
-        # the original transition might no longer be appropriate.
-        planOptions.transition = up.fragment.config.fallbackTransition ? @options.transition
-      new up.ExtractPlan(candidate, planOptions)
-
-  buildCandidates: (selector) ->
-    candidates = [selector, @options.fallback, up.fragment.config.fallbacks]
-    candidates = u.flatten(candidates)
-    # Remove undefined, null and false from the list
-    candidates = u.filter(candidates, u.isTruthy)
-    candidates = u.uniq(candidates)
-
-    if @options.fallback == false || @options.provideTarget
-      # Use the first defined candidate, but not `selector` since that
-      # might be an undefined options.failTarget
-      candidates = [candidates[0]]
-    candidates
-
-  oldPlan: =>
-    @detectPlan('oldExists')
-
-  newPlan: =>
-    @detectPlan('newExists')
-
-  matchingPlan: =>
-    @detectPlan('matchExists')
-
-  detectPlan: (checker) =>
-    u.find @plans, (plan) -> plan[checker]()
-
-  bestPreflightSelector: =>
-    if @options.provideTarget
-      # We know that the target will be created right before swapping,
-      # so just assume the first plan will work.
-      plan = @plans[0]
-    else
-      plan = @oldPlan()
-
-    if plan
-      plan.resolveNesting()
-      plan.selector()
-    else
-      @oldPlanNotFound()
-
-  bestMatchingSteps: =>
-    if plan = @matchingPlan()
-      # Only when we have a match in the required selectors, we
-      # append the optional steps for [up-hungry] elements.
-      plan.addHungrySteps()
-      plan.resolveNesting()
-      plan.steps
-    else
-      @matchingPlanNotFound()
-
-  matchingPlanNotFound: =>
-    # The job of this method is to simply throw an error.
-    # However, we will investigate the reasons for the failure
-    # so we can provide a more helpful error message.
-    if @newPlan()
-      @oldPlanNotFound()
-    else
-      if @oldPlan()
-        message = "Could not find #{@options.humanizedTarget} in response"
-      else
-        message = "Could not match #{@options.humanizedTarget} in current page and response"
-      if @options.inspectResponse
-        inspectAction = { label: 'Open response', callback: @options.inspectResponse }
-      up.fail(["#{message} (tried %o)", @candidates], action: inspectAction)
-
-  oldPlanNotFound: =>
-    layerProse = @options.layer
-    layerProse = 'page, modal or popup' if layerProse == 'auto'
-    up.fail("Could not find #{@options.humanizedTarget} in current #{layerProse} (tried %o)", @candidates)

data/lib/assets/javascripts/unpoly/classes/extract_plan.coffee

@@ -1,111 +0,0 @@
-u = up.util
-e = up.element
-
-class up.ExtractPlan
-
-  constructor: (selector, options) ->
-    @reveal = options.reveal
-    @origin = options.origin
-    @hungry = options.hungry
-    @transition = options.transition
-    @response = options.response
-    @oldLayer = options.layer
-    originalSelector = e.resolveSelector(selector, @origin)
-    @parseSteps(originalSelector)
-
-  findOld: =>
-    u.each @steps, (step) =>
-      step.oldElement = up.fragment.first(step.selector, layer: @oldLayer)
-
-  findNew: =>
-    u.each @steps, (step) =>
-      # The response has no layers. It's always just the page.
-      step.newElement = @response.first(step.selector)
-
-  oldExists: =>
-    @findOld()
-    u.every @steps, (step) -> step.oldElement
-
-  newExists: =>
-    @findNew()
-    u.every @steps, (step) -> step.newElement
-
-  matchExists: =>
-    @oldExists() && @newExists()
-
-  addSteps: (steps) =>
-    @steps = @steps.concat(steps)
-    
-  resolveNesting: =>
-    return if @steps.length < 2
-
-    compressed = u.copy(@steps)
-
-    # When two replacements target the same element, we would process
-    # the same content twice. We never want that, so we only keep the first step.
-    compressed = u.uniqBy(compressed, (step) -> step.oldElement)
-
-    compressed = u.filter compressed, (candidateStep, candidateIndex) =>
-      u.every compressed, (rivalStep, rivalIndex) =>
-        if rivalIndex == candidateIndex
-          true
-        else
-          candidateElement = candidateStep.oldElement
-          rivalElement = rivalStep.oldElement
-          rivalStep.pseudoClass || !rivalElement.contains(candidateElement)
-
-    # If we revealed before, we should reveal now
-    compressed[0].reveal = @steps[0].reveal
-    @steps = compressed
-
-  selector: =>
-    u.map(@steps, 'expression').join(', ')
-
-  parseSteps: (originalSelector) =>
-    comma = /\ *,\ */
-
-    @steps = []
-
-    disjunction = originalSelector.split(comma)
-
-    u.each disjunction, (expression, i) =>
-      expressionParts = expression.match(/^(.+?)(?:\:(before|after))?$/)
-      expressionParts or up.fail('Could not parse selector literal "%s"', expression)
-      selector = expressionParts[1]
-      if selector == 'html'
-        # If someone really asked us to replace the <html> root, the best
-        # we can do is replace the <body>.
-        selector = 'body'
-
-      pseudoClass = expressionParts[2]
-
-      # When extracting multiple selectors, we only want to reveal the first element.
-      # So we set the { reveal } option to false for the next iteration.
-      doReveal = if i == 0 then @reveal else false
-
-      @steps.push
-        expression: expression
-        selector: selector
-        pseudoClass: pseudoClass
-        transition: @transition
-        origin: @origin
-        reveal: doReveal
-
-  addHungrySteps: =>
-    hungrySteps = []
-    if @hungry
-      hungries = e.all(up.radio.hungrySelector())
-      transition = up.radio.config.hungryTransition ? @transition
-      for hungry in hungries
-        selector = e.toSelector(hungry)
-        if newHungry = @response.first(selector)
-          hungrySteps.push
-            selector: selector
-            oldElement: hungry
-            newElement: newHungry
-            transition: transition
-            reveal: false # we never auto-reveal a hungry element
-            origin: null # don't let the hungry element auto-close a non-sticky modal or popup
-
-    @addSteps(hungrySteps)
-

data/lib/assets/javascripts/unpoly/classes/field_observer.coffee

@@ -1,80 +0,0 @@
-u = up.util
-e = up.element
-
-class up.FieldObserver
-
-  constructor: (fieldOrFields, options, @callback) ->
-    @fields = e.list(fieldOrFields)
-    @delay = options.delay
-    @batch = options.batch
-
-  start: =>
-    @scheduledValues = null
-    @processedValues = @readFieldValues()
-    @currentTimer = undefined
-    @callbackRunning = false
-    # Although (depending on the browser) we only need/receive either input or change,
-    # we always bind to both events in case another script manually triggers it.
-    @unbind = up.on(@fields, 'input change', @check)
-
-  stop: =>
-    @unbind()
-    @cancelTimer()
-
-  cancelTimer: =>
-    clearTimeout(@currentTimer)
-    @currentTimer = undefined
-
-  scheduleTimer: =>
-    @cancelTimer()
-    @currentTimer = u.timer @delay, =>
-      @currentTimer = undefined
-      @requestCallback()
-
-  scheduleValues: (values) =>
-    @scheduledValues = values
-    @scheduleTimer()
-
-  isNewValues: (values) =>
-    !u.isEqual(values, @processedValues) && !u.isEqual(@scheduledValues, values)
-
-  requestCallback: =>
-    if @scheduledValues != null && !@currentTimer && !@callbackRunning
-      diff = @changedValues(@processedValues, @scheduledValues)
-      @processedValues = @scheduledValues
-      @scheduledValues = null
-      @callbackRunning = true
-
-      callbackReturnValues = []
-      if @batch
-        callbackReturnValues.push(@callback(diff))
-      else
-        for name, value of diff
-          callbackReturnValues.push(@callback(value, name))
-
-      # Promise.all() will wait for any promises that might be
-      # contained in the `callbackReturnValues` array.
-      callbacksDone = Promise.all(callbackReturnValues)
-
-      u.always callbacksDone, =>
-        @callbackRunning = false
-        @requestCallback()
-
-  changedValues: (previous, next) ->
-    changes = {}
-    keys = Object.keys(previous)
-    keys = keys.concat(Object.keys(next))
-    keys = u.uniq(keys)
-    for key in keys
-      previousValue = previous[key]
-      nextValue = next[key]
-      unless u.isEqual(previousValue, nextValue)
-        changes[key] = nextValue
-    changes
-
-  readFieldValues: =>
-    up.Params.fromFields(@fields).toObject()
-
-  check: =>
-    values = @readFieldValues()
-    @scheduleValues(values) if @isNewValues(values)

data/lib/assets/javascripts/unpoly/classes/focus_follower.coffee

@@ -1,29 +0,0 @@
-## Working example for this: https://codepen.io/anon/pen/MBVewo
-#class up.FocusFollower
-#
-#  constructor: ->
-#    @discardDelay = 80
-#    fieldSelector = up.form.fieldSelector()
-#    $(document).on('focusin', fieldSelector, @fieldFocused)
-#    $(document).on('focusout', fieldSelector, @fieldBlurred)
-#    @reset()
-#
-#  reset: ->
-#    clearTimeout(@discardTimer)
-#    @field = undefined
-#
-#  fieldFocused: (event) =>
-#    clearTimeout(@discardTimer)
-#    @field = event.currentTarget
-#
-#  fieldBlurred: (event) =>
-#    clearTimeout(@discardTimer)
-#    @discardTimer = u.timer(@discardDelay, @discardField)
-#
-#  discardField: =>
-#    @field = undefined
-#
-#  lastField: ->
-#    if u.isDetached(@field)
-#      @discardField()
-#    @field

data/lib/assets/javascripts/unpoly/classes/follow_variant.coffee

@@ -1,56 +0,0 @@
-u = up.util
-e = up.element
-
-class up.FollowVariant
-
-  constructor: (selector, options) ->
-    # @followLink() will wrap @followNow() with event submission and [up-active] feedback
-    @followNow = options.follow
-    @preloadLink = options.preload
-    @selectors = u.splitValues(selector, ',')
-
-  onClick: (event, link) =>
-    if up.link.shouldProcessEvent(event, link)
-      if e.matches(link, '[up-instant]')
-        # If the link was already processed on mousedown, we still need
-        # to prevent this later click event's chain.
-        up.event.halt(event)
-      else
-        up.event.consumeAction(event)
-        @followLink(link)
-    else
-      # For tests
-      up.link.allowDefault(event)
-
-  onMousedown: (event, link) =>
-    if up.link.shouldProcessEvent(event, link)
-      up.event.consumeAction(event)
-      @followLink(link)
-
-  fullSelector: (additionalClause = '') =>
-    parts = []
-    @selectors.forEach (variantSelector) ->
-      for tagSelector in ['a', '[up-href]']
-        parts.push "#{tagSelector}#{variantSelector}#{additionalClause}"
-    parts.join(', ')
-
-  registerEvents: ->
-    up.on 'click', @fullSelector(), (args...) =>
-      u.muteRejection @onClick(args...)
-    up.on 'mousedown', @fullSelector('[up-instant]'), (args...) =>
-      u.muteRejection @onMousedown(args...)
-
-  followLink: (link, options = {}) =>
-    promise = up.event.whenEmitted('up:link:follow', log: 'Following link', target: link)
-    promise = promise.then =>
-      up.feedback.start(link) unless options.preload
-      @followNow(link, options)
-    unless options.preload
-      # Make sure we always remove .up-active, even if the follow fails or the user
-      # does not confirm an [up-confirm] link. However, don't re-assign promise
-      # to the result of up.always() since that would change the state of promise.
-      u.always promise, -> up.feedback.stop(link)
-    promise
-
-  matchesLink: (link) =>
-    e.matches(link, @fullSelector())

data/lib/assets/javascripts/unpoly/classes/html_parser.coffee

@@ -1,46 +0,0 @@
-u = up.util
-e = up.element
-
-class up.HtmlParser
-
-  constructor: (@html) ->
-    @wrapNoscriptInHtml()
-    @parsedDoc = e.createDocumentFromHtml(@html)
-
-  title: ->
-    @parsedDoc.querySelector("head title")?.textContent
-
-  first: (selector) ->
-    e.first(@parsedDoc, selector)
-
-  prepareForInsertion: (element) ->
-    @unwrapNoscriptInElement(element)
-
-  wrapNoscriptInHtml: ->
-    # We wrap <noscript> tags into a <div> for two reasons:
-    #
-    # (1) IE11 and Edge cannot find <noscript> tags with jQuery or querySelector() or
-    #     getElementsByTagName() when the tag was created by DOMParser. This is a bug.
-    #     https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/12453464/
-    #
-    # (2) The children of a <nonscript> tag are expected to be a verbatim text node
-    #     in a scripting-capable browser. However, due to rules in the DOMParser spec,
-    #     the children are parsed into actual DOM nodes. This confuses libraries that
-    #     work with <noscript> tags, such as lazysizes.
-    #     http://w3c.github.io/DOM-Parsing/#dom-domparser-parsefromstring
-    #
-    # We will unwrap the wrapped <noscript> tags when a fragment is requested with
-    # #first(), and only in the requested fragment.
-    noscriptPattern = /<noscript[^>]*>((.|\s)*?)<\/noscript>/ig
-    @html = @html.replace noscriptPattern, (match, content) =>
-      @didWrapNoscript = true
-      '<div class="up-noscript" data-html="' + u.escapeHtml(content) + '"></div>'
-
-  unwrapNoscriptInElement: (element) ->
-    return unless @didWrapNoscript
-    wrappedNoscripts = element.querySelectorAll('.up-noscript')
-    for wrappedNoscript in wrappedNoscripts
-      wrappedContent = wrappedNoscript.getAttribute('data-html')
-      noscript = document.createElement('noscript')
-      noscript.textContent = wrappedContent
-      wrappedNoscript.parentNode.replaceChild(noscript, wrappedNoscript)

data/lib/assets/javascripts/unpoly/classes/motion_controller.coffee

@@ -1,157 +0,0 @@
-u = up.util
-e = up.element
-
-class up.MotionController
-
-  constructor: (name) ->
-    @activeClass = "up-#{name}"
-    @dataKey = "up-#{name}-finished"
-    @selector = ".#{@activeClass}"
-    @finishEvent = "up:#{name}:finish"
-    @finishCount = 0
-    @clusterCount = 0
-
-  ###**
-  Finishes all animations in the given elements' ancestors and
-  descendants, then calls the given function.
-
-  The function is expected to return a promise that is fulfilled when
-  the animation ends. The function is also expected to listen to
-  `this.finishEvent` and instantly skip to the last frame
-  when the event is observed.
-
-  The animation is tracked so it can be
-  [`finished`](/up.MotionController.finish) later.
-
-  @method startFunction
-  @param {Element|List<Element>} cluster
-    A list of elements that will be affected by the motion.
-  @param {Function(): Promise} startMotion
-  @param {Object} [memory.trackMotion=true]
-  @return {Promise}
-    A promise that is fulfilled when the animation ends.
-  ###
-  startFunction: (cluster, startMotion, memory = {}) =>
-    cluster = e.list(cluster)
-
-    # Some motions might reject after starting. E.g. a scrolling animation
-    # will reject when the user scrolls manually during the animation. For
-    # the purpose of this controller, we just want to know when the animation
-    # has setteld, regardless of whether it was resolved or rejected.
-    mutedAnimator = -> u.muteRejection(startMotion())
-
-    # Callers can pass an options hash `memory` in which we store a { trackMotion }
-    # property. With this we can prevent tracking the same motion multiple times.
-    # This is an issue when composing a transition from two animations, or when
-    # using another transition from within a transition function.
-    memory.trackMotion = memory.trackMotion ? up.motion.isEnabled()
-    if memory.trackMotion is false
-      # Since we don't want recursive tracking or finishing, we could run
-      # the animator() now. However, since the else branch is async, we push
-      # the animator into the microtask queue to be async as well.
-      u.microtask(mutedAnimator)
-    else
-      memory.trackMotion = false
-      @finish(cluster).then =>
-        promise = @whileForwardingFinishEvent(cluster, mutedAnimator)
-        promise = promise.then => @unmarkCluster(cluster)
-        # Attach the modified promise to the cluster's elements
-        @markCluster(cluster, promise)
-        promise
-
-  ###*
-  Finishes all animations in the given elements' ancestors and
-  descendants, then calls `motion.start()`.
-
-  Also listens to `this.finishEvent` on the given elements.
-  When this event is observed, calls `motion.finish()`.
-
-  @method startMotion
-  @param {Element|List<Element>} cluster
-  @param {up.Motion} motion
-  @param {Object} [memory.trackMotion=true]
-  ###
-  startMotion: (cluster, motion, memory = {}) ->
-    start = -> motion.start()
-    finish = -> motion.finish()
-    unbindFinish = up.on(cluster, @finishEvent, finish)
-    promise = @startFunction(cluster, start, memory)
-    promise = promise.then(unbindFinish)
-    promise
-
-  ###**
-  @method finish
-  @param {List<Element>} [elements]
-    If no element is given, finishes all animations in the documnet.
-    If an element is given, only finishes animations in its subtree and ancestors.
-  @return {Promise} A promise that is fulfilled when animations have finished.
-  ###
-  finish: (elements) =>
-    @finishCount++
-    return Promise.resolve() if @clusterCount == 0 || !up.motion.isEnabled()
-    elements = @expandFinishRequest(elements)
-    allFinished = u.map(elements, @finishOneElement)
-    Promise.all(allFinished)
-
-  expandFinishRequest: (elements) =>
-    if elements
-      u.flatMap elements, (el) =>
-        e.list(e.closest(el, @selector), e.all(el, @selector))
-    else
-      # If no reference elements were given, we finish every matching
-      # element on the screen.
-      e.all(@selector)
-
-  isActive: (element) =>
-    element.classList.contains(@activeClass)
-
-  finishOneElement: (element) =>
-    # Animating code is expected to listen to this event, fast-forward
-    # the animation and resolve their promise. All built-ins like
-    # `up.animate`, `up.morph`, or `up.scroll` behave that way.
-    @emitFinishEvent(element)
-
-    # If animating code ignores the event, we cannot force the animation to
-    # finish from here. We will wait for the animation to end naturally before
-    # starting the next animation.
-    @whenElementFinished(element)
-
-  emitFinishEvent: (element, eventAttrs = {}) =>
-    eventAttrs = u.merge({ target: element, log: false }, eventAttrs)
-    up.emit(@finishEvent, eventAttrs)
-
-  whenElementFinished: (element) =>
-    # There are some cases related to element ghosting where an element
-    # has the class, but not the data value. In that case simply return
-    # a resolved promise.
-    element[@dataKey] || Promise.resolve()
-
-  markCluster: (cluster, promise) =>
-    @clusterCount++
-    for element in cluster
-      element.classList.add(@activeClass)
-      element[@dataKey] = promise
-
-  unmarkCluster: (cluster) =>
-    @clusterCount--
-    for element in cluster
-      element.classList.remove(@activeClass)
-      delete element[@dataKey]
-
-  whileForwardingFinishEvent: (cluster, fn) =>
-    return fn() if cluster.length < 2
-    doForward = (event) =>
-      unless event.forwarded
-        u.each cluster, (element) =>
-          if element != event.target && @isActive(element)
-            @emitFinishEvent(element, forwarded: true)
-
-    # Forward the finish event to the ghost that is actually animating
-    unbindFinish = up.on(cluster, @finishEvent, doForward)
-    # Our own pseudo-animation finishes when the actual animation on $ghost finishes
-    fn().then(unbindFinish)
-
-  reset: =>
-    @finish().then =>
-      @finishCount = 0
-      @clusterCount = 0