atome-opal-browser 0.3.9.5

data/opal/browser/delay.rb

@@ -0,0 +1,94 @@
+module Browser
+
+# Allows you to delay the call to a function which gets called after the
+# given time.
+#
+# @see https://developer.mozilla.org/en-US/docs/Web/API/Window.setTimeout
+class Delay
+  # @!attribute [r] after
+  # @return [Float] the seconds after which the block is called
+  attr_reader :after
+
+  # Create and start a timeout.
+  #
+  # @param window [Window] the window to start the timeout on
+  # @param time [Float] seconds after which the block is called
+  def initialize(window, time, &block)
+    @window = Native.convert(window)
+    @after  = time
+    @block  = block
+  end
+
+  # Abort the timeout.
+  def abort
+    `#@window.clearTimeout(#@id)`
+  end
+
+  # Start the delay.
+  def start
+    @id = `#@window.setTimeout(#{@block.to_n}, #@after * 1000)`
+  end
+end
+
+class Window
+  # Execute a block after the given seconds.
+  #
+  # @param time [Float] the seconds after it gets called
+  #
+  # @return [Delay] the object representing the timeout
+  def after(time, &block)
+    Delay.new(@native, time, &block).tap(&:start)
+  end
+
+  # Execute a block after the given seconds, you have to call [#start] on it
+  # yourself.
+  #
+  # @param time [Float] the seconds after it gets called
+  #
+  # @return [Delay] the object representing the timeout
+  def after!(time, &block)
+    Delay.new(@native, time, &block)
+  end
+
+  # Returns a promise that will resolve after the given seconds.
+  #
+  # @param time [Float] the seconds after it gets called
+  #
+  # @return [Promise] the promise that will resolve after timeout happens
+  def resolve_after(time)
+    promise = Promise.new
+    Delay.new(@native, time) { promise.resolve }.start
+    promise
+  end
+end
+
+end
+
+module Kernel
+  # (see Browser::Window#after)
+  def after(time, &block)
+    $window.after(time, &block)
+  end
+
+  # (see Browser::Window#after!)
+  def after!(time, &block)
+    $window.after!(time, &block)
+  end
+
+  # (see Browser::Window#resolve_after)
+  def resolve_after(time)
+    $window.resolve_after(time)
+  end
+end
+
+class Proc
+  # (see Browser::Window#after)
+  def after(time)
+    $window.after(time, &self)
+  end
+
+  # (see Browser::Window#after!)
+  def after!(time)
+    $window.after!(time, &self)
+  end
+end

data/opal/browser/dom/attribute.rb

@@ -0,0 +1,26 @@
+module Browser; module DOM
+
+# Encapsulates an {Element} attribute.
+class Attribute
+  include Browser::NativeCachedWrapper
+
+  # @!attribute [r] name
+  # @return [String] the name of the attribute
+  alias_native :name
+
+  # @!attribute value
+  # @return [String] the value of the attribute
+  alias_native :value
+  alias_native :value=
+
+  # Returns true if the attribute is an id.
+  if Browser.supports? 'Attr.isId'
+    alias_native :id?, :isId
+  else
+    def id?
+      name == :id
+    end
+  end
+end
+
+end; end

data/opal/browser/dom/builder.rb

@@ -0,0 +1,107 @@
+# Temporary fix for a bug in String#scan
+module Paggio::Utils
+  def self.heredoc(string)
+    string
+  end
+end
+
+class Paggio::HTML::Element < BasicObject
+  def on(*args, &block)
+    (@on ||= []) << [args, block]
+  end
+end
+
+module Browser; module DOM
+
+class Builder
+  def self.to_h
+    @builders ||= {}
+  end
+
+  def self.for(klass, &block)
+    if block
+      to_h[klass] = block
+    else
+      to_h[klass]
+    end
+  end
+
+  def self.build(builder, item)
+    to_h.each {|klass, block|
+      if klass === item
+        return block.call(builder, item)
+      end
+    }
+
+    raise ArgumentError, "cannot build unknown item #{item}"
+  end
+
+  attr_reader :document, :element
+
+  NEW_PAGGIO = (Paggio::HTML.instance_method(:build!) rescue false)
+
+  def initialize(document, builder=nil, &block)
+    @document = document
+
+    # Compatibility issue due to an unreleased Paggio gem.
+    # Let's try to support both versions. When Paggio is released,
+    # we may remove it.
+
+    if NEW_PAGGIO
+      @builder = Paggio::HTML.new(defer: true, &block)
+
+      build = proc do
+        @builder.build!(force_call: !!builder)
+        @roots = @builder.each.map { |e| Builder.build(self, e) }
+      end
+
+      if builder
+        builder.extend!(@builder, &build)
+      else
+        build.()
+      end
+    else
+      @builder = Paggio::HTML.new(&block)
+      @roots = @builder.each.map { |e| Builder.build(self, e) }
+    end
+  end
+
+  def to_a
+    @roots
+  end
+end
+
+Builder.for String do |b, item|
+  b.document.create_text(item)
+end
+
+Builder.for Paggio::HTML::Element do |b, item|
+  options = {}
+
+  options[:attrs] = `item.attributes` if Hash === `item.attributes`
+  options[:classes] = `item.class_names`
+
+  dom = b.document.create_element(`item.name`, **options)
+
+  if on = `item.on || nil`
+    on.each {|args, block|
+      dom.on(*args, &block)
+    }
+  end
+
+  if inner = `item.inner_html || nil`
+    dom.inner_html = inner
+  else
+    item.each {|child|
+      dom << Builder.build(b, child)
+    }
+  end
+
+  dom
+end
+
+Builder.for DOM::Node do |b, item|
+  item
+end
+
+end; end

data/opal/browser/dom/cdata.rb

@@ -0,0 +1,9 @@
+module Browser; module DOM
+
+class CDATA < Text
+  def inspect
+    "#<DOM::CDATA: #{value}>"
+  end
+end
+
+end; end

data/opal/browser/dom/character_data.rb

@@ -0,0 +1,73 @@
+module Browser; module DOM
+
+class CharacterData < Node
+  # Append data to the node.
+  #
+  # @param string [String] the data to add
+  #
+  # @return [self]
+  def append(string)
+    `#@native.appendData(string)`
+
+    self
+  end
+
+  # @!attribute [r] data
+  # @return [String] the data of the node
+  def data
+    `#@native.data`
+  end
+
+  # Delete data from the node.
+  #
+  # @param count [Integer] how much data to delete
+  # @param offset [Integer] the offset to start at
+  #
+  # @return [self]
+  def delete(count, offset = 0)
+    `#@native.deleteData(offset, count)`
+
+    self
+  end
+
+  # Insert data in the node.
+  #
+  # @param string [String] the data to insert
+  # @param offset [Integer] the offset to start at
+  #
+  # @return [self]
+  def insert(string, offset = 0)
+    `#@native.insertData(offset, string)`
+
+    self
+  end
+
+  # @!attribute [r] length
+  # @return [Integer] the length of the node
+  alias_native :length
+
+  # Replace data in the node.
+  #
+  # @param string [String] the data to replace with
+  # @param offset [Integer] the offset to start at
+  # @param count [Integer] how much data to replace
+  #
+  # @return [self]
+  def replace(string, offset = 0, count = `#@native.length`)
+    `#@native.replaceData(offset, count, string)`
+
+    self
+  end
+
+  # Get a substring of the data.
+  #
+  # @param count [Integer] how much data to lice
+  # @param offset [Integer] the offset to start at
+  #
+  # @return [String] the substring
+  def substring(count, offset = 0)
+    `#@native.substringData(offset, count)`
+  end
+end
+
+end; end

data/opal/browser/dom/comment.rb

@@ -0,0 +1,9 @@
+module Browser; module DOM
+
+class Comment < CharacterData
+  def inspect
+    "#<DOM::Comment: #{value}>"
+  end
+end
+
+end; end

data/opal/browser/dom/document.rb

@@ -0,0 +1,217 @@
+module Browser; module DOM
+
+class Document < Element
+  include DocumentOrShadowRoot
+
+  # Get the first element matching the given ID, CSS selector or XPath.
+  #
+  # @param what [String] ID, CSS selector or XPath
+  #
+  # @return [Element?] the first matching element
+  def [](what)
+    %x{
+      var result = #@native.getElementById(what);
+
+      if (result) {
+        return #{DOM(`result`)};
+      }
+    }
+
+    css(what).first || xpath(what).first
+  end
+
+  alias at []
+
+  # @!attribute [r] body
+  # @return [Element?] the body element of the document
+  def body
+    DOM(`#@native.body`)
+  rescue ArgumentError
+    raise '$document.body is not defined; try to wrap your code in $document.ready{}'
+  end
+
+  # Create a new element for the document.
+  #
+  # @param name [String] the node name
+  # @param builder [Browser::DOM::Builder] optional builder to append element to
+  # @param options [String] :namespace optional namespace name
+  # @param options [String] :is optional WebComponents is parameter
+  # @param options [String] :id optional id to set
+  # @param options [Array<String>] :classes optional classes to set
+  # @param options [Hash] :attrs optional attributes to set
+  #
+  # @return [Element]
+  def create_element(name, builder=nil, **options, &block)
+    opts = {}
+
+    if options[:is] ||= (options.dig(:attrs, :is))
+      opts[:is] = options[:is]
+    end
+
+    if ns = options[:namespace]
+      elem = `#@native.createElementNS(#{ns}, #{name}, #{opts.to_n})`
+    else
+      elem = `#@native.createElement(name, #{opts.to_n})`
+    end
+
+    if options[:classes]
+      `#{elem}.className = #{Array(options[:classes]).join(" ")}`
+    end
+
+    if options[:id]
+      `#{elem}.id = #{options[:id]}`
+    end
+
+    if options[:attrs]
+      options[:attrs].each do |k,v|
+        next unless v
+        `#{elem}.setAttribute(#{k}, #{v})`
+      end
+    end
+
+    dom = DOM(elem)
+
+    if block_given?
+      dom.inner_dom(builder, &block)
+    end
+
+    if builder
+      builder << dom
+    end
+
+    dom
+  end
+
+  # Create a new document fragment.
+  #
+  # @return [DocumentFragment]
+  def create_document_fragment
+    DOM(`#@native.createDocumentFragment()`)
+  end
+
+  # Create a new text node for the document.
+  #
+  # @param content [String] the text content
+  #
+  # @return [Text]
+  def create_text(content)
+    DOM(`#@native.createTextNode(#{content})`)
+  end
+
+  # Create a new comment node for the document.
+  #
+  # @param content [String] the comment content
+  #
+  # @return [Comment]
+  def create_comment(content)
+    DOM(`#@native.createComment(#{content})`)
+  end
+
+  def document
+    self
+  end
+
+  # @!attribute [r] head
+  # @return [Element?] the head element of the document
+  def head
+    DOM(`#@native.getElementsByTagName("head")[0]`)
+  end
+
+  def inspect
+    "#<DOM::Document>"
+  end
+
+  if Browser.supports? 'Event.addListener'
+    def ready(&block)
+      raise ArgumentError, 'no block given' unless block
+
+      return block.call if ready?
+
+      on 'dom:load' do |e|
+        e.off
+
+        block.call
+      end
+    end
+  elsif Browser.supports? 'Event.attach'
+    def ready(&block)
+      raise ArgumentError, 'no block given' unless block
+
+      return block.call if ready?
+
+      on 'ready:state:change' do |e|
+        if ready?
+          e.off
+
+          block.call
+        end
+      end
+    end
+  else
+    # Wait for the document to be ready and call the block.
+    def ready(&block)
+      raise NotImplementedError, 'document ready unsupported'
+    end
+  end
+
+  # Check if the document is ready.
+  def ready?
+    `#@native.readyState === "complete" || #@native.readyState === "interactive"`
+  end
+
+  # @!attribute referrer
+  # @return [String] the referring document, or empty string if direct access
+  def referrer
+    `#@native.referrer`
+  end
+
+  # @!attribute root
+  # @return [Element?] the root element of the document
+  def root
+    DOM(`#@native.documentElement`)
+  end
+
+  def root=(element)
+    `#@native.documentElement = #{Native.convert(element)}`
+  end
+
+  # @!attribute title
+  # @return [String] the document title
+  def title
+    `#@native.title`
+  end
+
+  def title=(value)
+    `#@native.title = value`
+  end
+
+  # @!attribute [r] hidden?
+  # @return [Boolean] is the page considered hidden?
+  def hidden?
+    `#@native.hidden`
+  end
+
+  # @!attribute [r] visibility
+  # @return [String] the visibility state of the document - prerender, hidden or visible
+  def visibility
+    `#@native.visibilityState`
+  end
+
+  if Browser.supports? 'Document.view'
+    def window
+      Window.new(`#@native.defaultView`)
+    end
+  elsif Browser.supports? 'Document.window'
+    def window
+      Window.new(`#@native.parentWindow`)
+    end
+  else
+    # @!attribute [r] window
+    # @return [Window] the window for the document
+    def window
+      raise NotImplementedError, 'window from document unsupported'
+    end
+  end
+end
+
+end; end

data/opal/browser/dom/document_fragment.rb

@@ -0,0 +1,25 @@
+module Browser; module DOM
+
+# TODO: DocumentFragment is not a subclass of Element, but
+#       a subclass of Node. It implements a ParentNode.
+#
+# @see https://github.com/opal/opal-browser/pull/46
+class DocumentFragment < Element
+  def self.new(node)
+    if self == DocumentFragment
+      if defined? `#{node}.mode`
+        ShadowRoot.new(node)
+      else
+        super
+      end
+    else
+      super
+    end
+  end
+
+  def self.create
+    $document.create_document_fragment
+  end
+end
+
+end; end

data/opal/browser/dom/document_or_shadow_root.rb

@@ -0,0 +1,19 @@
+module Browser; module DOM
+
+# Document and ShadowRoot have some methods and properties in common.
+# This solution mimics how it's done in DOM.
+#
+# @see https://developer.mozilla.org/en-US/docs/Web/API/DocumentOrShadowRoot
+module DocumentOrShadowRoot
+  # @!attribute [r] style_sheets
+  # @return [Array<CSS::StyleSheet>] the style sheets for the document
+  def style_sheets
+    Native::Array.new(`#@native.styleSheets`) {|e|
+      CSS::StyleSheet.new(e)
+    }
+  end
+
+  alias stylesheets style_sheets
+end
+
+end; end

data/opal/browser/dom/element/attributes.rb

@@ -0,0 +1,111 @@
+module Browser; module DOM; class Element < Node
+
+class Attributes
+  attr_reader :namespace
+
+  def initialize(element, options)
+    @element   = element
+    @native    = element.to_n
+    @namespace = options[:namespace]
+  end
+
+  if Browser.supports?('Element.className') || Browser.supports?('Element.htmlFor')
+    def [](name, options = {})
+      if name == :class && Browser.supports?('Element.className')
+        name = :className
+      elsif name == :for && Browser.supports?('Element.htmlFor')
+        name = :htmlFor
+      end
+
+      if namespace = options[:namespace] || @namespace
+        `#@native.getAttributeNS(#{namespace.to_s}, #{name.to_s}) || nil`
+      else
+        `#@native.getAttribute(#{name.to_s}) || nil`
+      end
+    end
+
+    def []=(name, value, options = {})
+      if name == :class && Browser.supports?('Element.className')
+        name = :className
+      elsif name == :for && Browser.supports?('Element.htmlFor')
+        name = :htmlFor
+      end
+
+      if namespace = options[:namespace] || @namespace
+        if value
+          `#@native.setAttributeNS(#{namespace.to_s}, #{name.to_s}, #{value})`
+        else
+          `#@native.removeAttributeNS(#{namespace.to_s}, #{name.to_s})`
+        end
+      else
+        if value
+          `#@native.setAttribute(#{name.to_s}, #{value.to_s})`
+        else
+          `#@native.removeAttribute(#{name.to_s})`
+        end
+      end
+    end
+  else
+    def [](name, options = {})
+      if namespace = options[:namespace] || @namespace
+        `#@native.getAttributeNS(#{namespace.to_s}, #{name.to_s}) || nil`
+      else
+        `#@native.getAttribute(#{name.to_s}) || nil`
+      end
+    end
+
+    def []=(name, value, options = {})
+      if namespace = options[:namespace] || @namespace
+        if value
+          `#@native.setAttributeNS(#{namespace.to_s}, #{name.to_s}, #{value})`
+        else
+          `#@native.removeAttributeNS(#{namespace.to_s}, #{name.to_s})`
+        end
+      else
+        if value
+          `#@native.setAttribute(#{name.to_s}, #{value.to_s})`
+        else
+          `#@native.removeAttribute(#{name.to_s})`
+        end
+      end
+    end
+  end
+
+  # Deletes an attribute with a given name
+  # @return [String] an attribute value before deletion
+  def delete(name)
+    attr = self[name]
+    self[name] = nil
+    attr
+  end
+
+  include Enumerable
+
+  def each(&block)
+    return enum_for :each unless block_given?
+
+    @element.attribute_nodes.each {|attr|
+      yield attr.name, attr.value
+    }
+
+    self
+  end
+
+  alias get []
+
+  def has_key?(name)
+    !!self[name]
+  end
+
+  def merge!(hash)
+    hash.each {|name, value|
+      self[name] = value
+    }
+
+    self
+  end
+
+  alias set []=
+end
+
+end; end; end