isomorfeus-preact 10.9.0 → 22.9.0.rc2

data/lib/redirect.rb

@@ -0,0 +1,34 @@
+class Redirect < Preact::Component
+  EVENT_PUSH_STATE = "pushState"
+  EVENT_REPLACE_STATE = "replaceState"
+
+  def initialize(props, context)
+    super(props, context)
+    if RUBY_ENGINE == 'opal'
+      @history = if `typeof window !== "undefined"`
+                    `window.history`
+                else
+                    `{ length: 1, state: null, scrollRestoration: "auto", pushState: function(e,t,n){}, replaceState: function(e,t,n){} }`
+                end
+      @base = ''
+    end
+  end
+
+  def navigate
+    if RUBY_ENGINE == 'opal'
+      to = props[:to] || props[:href]
+      m = props[:replace] ? EVENT_REPLACE_STATE : EVENT_PUSH_STATE
+      `#@history[m](null, "", to[0] === "~" ? to.slice(1) : #@base + to)`
+      context[:router][:callback].call if context[:router].key?(:callback)
+    end
+  end
+
+  render do
+    if RUBY_ENGINE == 'opal'
+      @base = context[:router][:base] if context[:router].key?(:base)
+      navigate
+    end
+    nil
+  end
+end
+Redirect.context_type = RouterContext

data/lib/route.rb

@@ -0,0 +1,15 @@
+class Route < Preact::Component
+  render do
+    route_match = @context[:router][:matcher].call(props[:path], @context[:location])
+    matches, params = props[:match] || route_match
+    return unless matches
+    component = props[:component]
+    if component
+      component = component.constantize if component.is_a?(String)
+      Preact.create_element(component, { params: params })
+    else
+      props[:children]
+    end
+  end
+end
+Route.context_type = RouterContext

data/lib/router.rb

@@ -0,0 +1,145 @@
+class Router < Preact::Component
+  EVENT_POP_STATE = "popstate"
+  EVENT_PUSH_STATE = "pushState"
+  EVENT_REPLACE_STATE = "replaceState"
+  EVENTS = [EVENT_POP_STATE, EVENT_PUSH_STATE, EVENT_REPLACE_STATE]
+
+  def initialize(props, context)
+    super(props, context)
+    @state = { update: 0 }
+    @router = nil
+    if RUBY_ENGINE == 'opal'
+      @browser = `typeof window !== "undefined"` ? true : false
+      rtr = self
+      @check_for_updates_n = `function() { #{rtr.call(:check_for_updates).call}; }`
+    else
+      @browser = false
+    end
+    @rbase = nil
+    @original_location = nil
+    @prev_hash = nil
+  end
+
+  def build_router(props, values)
+    { base: "",
+      matcher: make_matcher(),
+      original_location: "/",
+      callback: call(:check_for_updates)
+    }.merge(props, values)
+  end
+
+  def check_for_updates
+    pathname = @browser ? current_pathname(@rbase) : current_pathname(@rbase, @original_location)
+    search = @browser ? `location.search` : ""
+    hash = pathname + search;
+    if @prev_hash != hash
+      @prev_hash = hash
+      set_state({ update: state[:update] + 1 })
+    end
+  end
+
+  def current_pathname(base, path)
+    unless path
+      path =  @browser ? `location.pathname` : ""
+    end
+    base = "" unless base
+    path.downcase.start_with?(base.downcase) ? (path[base.size..-1] || "/") : "~" + path
+  end
+
+  def escape_rx(str)
+    str.gsub(/([.+*?=^!:${}()\[\]\|\/\\])/, "\\1")
+  end
+
+  # returns a segment representation in Regexp based on flags
+  # adapted and simplified version from path-to-regexp sources
+  def rx_for_segment(repeat, optional, prefix)
+    capture = repeat ? "((?:[^\\/]+?)(?:\\/(?:[^\\/]+?))*)" : "([^\\/]+?)"
+    capture = "(?:\\/" + capture + ")" if (optional && prefix)
+    capture + (optional ? "?" : "")
+  end
+
+  def path_to_regexp(pattern)
+    group_rx = /:([A-Za-z0-9_]+)([?+*]?)/
+
+    pos = 0
+    keys = []
+    result = ""
+
+    while (match = group_rx.match(pattern, pos))
+      mod = match[2]
+      segment = match[1]
+
+      # :foo  [1]      (  )
+      # :foo? [0 - 1]  ( o)
+      # :foo+ [1 - ∞]  (r )
+      # :foo* [0 - ∞]  (ro)
+      repeat = mod === "+" || mod === "*"
+      optional = mod === "?" || mod === "*"
+      prefix = optional && pattern[match.begin(0) - 1] == "/" ? 1 : 0
+
+      prev = pattern[pos...(match.begin(0) - prefix)]
+      keys.push({ name: segment.to_sym })
+      pos = match.end(0)
+      if RUBY_ENGINE == 'opal'
+        result += "#{escape_rx(prev)}#{rx_for_segment(repeat, optional, prefix)}"
+      else
+        result << "#{escape_rx(prev)}#{rx_for_segment(repeat, optional, prefix)}"
+      end
+    end
+
+    if RUBY_ENGINE == 'opal'
+      result += escape_rx(pattern[pos..-1])
+    else
+      result << escape_rx(pattern[pos..-1])
+    end
+    [ Regexp.new("^" + result + "(?:\\/)?$", Regexp::IGNORECASE), keys]
+  end
+
+  def get_regexp(cache, pattern)
+    # obtains a cached regexp version of the pattern
+    cache[pattern] || (cache[pattern] = path_to_regexp(pattern))
+  end
+
+  def make_matcher
+    cache = {}
+
+    proc do |pattern, path|
+      regexp, keys = get_regexp(cache, pattern || "")
+      out = regexp.match(path)
+      if !out
+        [false, nil]
+      else
+        # formats an object with matched params
+        i = 0
+        params = keys.reduce({}) do |p, key|
+          p[key[:name]] = out[i += 1]
+          p
+        end
+        [true, params]
+      end
+    end
+  end
+
+  render do
+    @router = build_router(props, { original_location: @context[:iso_location] }) if !@router
+    @rbase = @router[:base]
+    @original_location = @router[:original_location]
+    loc = @browser ? current_pathname(@rbase) : current_pathname(@rbase, @original_location)
+    @prev_hash = @browser ? loc + `location.search` : loc
+    Preact.create_element(RouterContext.Provider, { value: { router: @router, location: loc }, children: props[:children] })
+  end
+
+  component_did_mount do
+    EVENTS.each do |event|
+      `window`.JS.addEventListener(event, @check_for_updates_n)
+    end
+    check_for_updates
+  end
+
+  component_will_unmount do
+    EVENTS.each do |event|
+      `window`.JS.removeEventListener(event, @check_for_updates_n)
+    end
+  end
+end
+Router.context_type = LucidApplicationContext

data/lib/switch.rb

@@ -0,0 +1,70 @@
+class Switch < Preact::Component
+  def initialize(props, context)
+    super(props, context)
+    if RUBY_ENGINE == 'opal'
+      @browser = `typeof window !== "undefined"` ? true : false
+    else
+      @browser = false
+    end
+  end
+
+  def flatten(children)
+    if children.is_a?(Array)
+      children.compact!
+      children.map! do |child|
+        if RUBY_ENGINE == 'opal'
+          if child.is_a?(Array)
+            flatten(child)
+          elsif `child.type === Opal.Fragment`
+            flatten(child.JS[:props][:children])
+          else
+            child
+          end
+        else
+          if child.is_a?(Array)
+            flatten(child)
+          elsif child.type == ::Fragment
+            flatten(child.JS[:props][:children])
+          else
+            child
+          end
+        end
+      end
+    else
+      [children]
+    end
+  end
+
+  render do
+    router = @context[:router]
+    base = router[:base]
+    matcher = router[:matcher]
+    originalLocation = router[:originalLocation]
+    children = flatten(props[:children])
+    location = props[:location]
+    child = nil
+    if RUBY_ENGINE == 'opal'
+      children.each do |vnode|
+        match = nil
+        # we don't require an element to be of type Route,
+        # but we do require it to contain a truthy `path` prop.
+        # this allows to use different components that wrap Route
+        # inside of a switch, for example <AnimatedRoute />.
+        if vnode.is_a?(VNode) && (match = (p = vnode.JS[:props][:path]) ? matcher.call(p, location || @context[:location]) : [true, {}])[0]
+          child = Preact.clone_element(vnode, { match: match })
+          break
+        end
+      end
+    else
+      children.each do |vnode|
+        match = nil
+        if vnode.is_a?(VNode) && (match = (p = vnode.props[:path]) ? matcher.call(p, location || @context[:location]) : [true, {}])[0]
+          child = Preact.clone_element(vnode, { match: match })
+          break
+        end
+      end
+    end
+    child
+  end
+end
+Switch.context_type = RouterContext

data/opal/iso_uri.rb

@@ -0,0 +1,29 @@
+require "uri/common"
+require "uri/generic"
+
+module URI
+  @@schemes = {}
+
+  class InvalidURIError < Exception
+  end
+  
+  def self.parse(url)
+      # scheme://conn_data/path?query#hash
+      match = url.match(%r[(\w+)://([^/]+)([^\?]+)(\?[^\#]+)?(\#.*)?])
+
+      _, scheme, connection_data, path, query, fragment = match.to_a
+
+      connection_data = connection_data.split(/@/)
+      userinfo = connection_data.size > 1 ? connection_data.first : nil
+      host, port = connection_data.last.split(/:/)
+
+      port = port.to_i
+      query = query[1..-1] if query
+
+      registry = opaque = nil
+
+      Generic.new(scheme, userinfo, host, port,
+                  registry, path, opaque, query,
+                  fragment)
+  end
+end

data/opal/uri/common.rb

@@ -0,0 +1,18 @@
+module Kernel
+
+  #
+  # Returns +uri+ converted to a URI object.
+  #
+  def URI(uri)
+    if uri.is_a?(URI::Generic)
+      uri
+    elsif uri = String.try_convert(uri)
+      URI.parse(uri)
+    else
+      raise ArgumentError,
+        "bad argument (expected URI object or URI string)"
+    end
+  end
+  module_function :URI
+end
+

data/opal/uri/generic.rb

@@ -0,0 +1,47 @@
+module URI
+  class Generic
+    attr_reader :scheme, :userinfo, :user, :password, :host, :port, :path,
+      :query, :fragment, :opaque, :registry
+
+    #
+    # An Array of the available components for URI::Generic
+    #
+    COMPONENT = [
+      :scheme,
+      :userinfo, :host, :port, :registry,
+      :path, :opaque,
+      :query,
+      :fragment
+    ]
+
+    def initialize(scheme,
+                   userinfo, host, port, registry,
+                   path, opaque,
+                   query,
+                   fragment,
+                   parser = nil,
+                   arg_check = false)
+      @scheme = scheme
+      @userinfo = userinfo
+      @host = host
+      @port = port
+      @path = path
+      @query = query
+      @fragment = fragment
+      @user, @password = userinfo.split(/:/) if userinfo
+    end
+
+    def ==(other)
+      self.class == other.class &&
+        component_ary == other.component_ary
+    end
+
+    protected
+
+    def component_ary
+      self.class::COMPONENT.collect do |x|
+        self.send(x)
+      end
+    end
+  end
+end