isomorfeus-react 16.9.24 → 16.10.0

data/lib/react/function_component/base.rb

@@ -1,9 +0,0 @@
-module React
-  module FunctionComponent
-    class Base
-      def self.inherited(base)
-        base.include(::React::FunctionComponent::Mixin)
-      end
-    end
-  end
-end

data/lib/react/function_component/creator.rb

@@ -1,32 +0,0 @@
-module React
-  module FunctionComponent
-    module Creator
-      def self.extended(base)
-        %x{
-          base.react_component = function(props) {
-            Opal.React.render_buffer.push([]);
-            Opal.React.active_components.push(base);
-            #{base.new(`props`).instance_exec(&`base.function_block`)};
-            Opal.React.active_components.pop();
-            return Opal.React.render_buffer.pop();
-          }
-        }
-
-        base_module = base.to_s.deconstantize
-        if base_module != ''
-          base_module.constantize.define_singleton_method(base.to_s.demodulize) do |*args, &block|
-            `Opal.React.internal_prepare_args_and_render(#{base}.react_component, args, block)`
-          end
-        else
-          Object.define_method(base.to_s) do |*args, &block|
-            `Opal.React.internal_prepare_args_and_render(#{base}.react_component, args, block)`
-          end
-        end
-
-        def create_function(&block)
-          `base.function_block = #{block}`
-        end
-      end
-    end
-  end
-end

data/lib/react/function_component/event_handler.rb

@@ -1,13 +0,0 @@
-module React
-  module FunctionComponent
-    module EventHandler
-      def event_handler(name, &block)
-        define_method(name) do |event, info|
-          ruby_event = ::React::SyntheticEvent.new(event)
-          block.call(ruby_event, info)
-        end
-        `self[name] = self.prototype['$' + name]`
-      end
-    end
-  end
-end

data/lib/react/function_component/mixin.rb

@@ -1,14 +0,0 @@
-module React
-  module FunctionComponent
-    module Mixin
-      def self.included(base)
-        base.include(::React::Component::Elements)
-        base.include(::React::Component::Features)
-        base.include(::React::FunctionComponent::API)
-        base.include(::React::FunctionComponent::Resolution)
-        base.extend(::React::FunctionComponent::EventHandler)
-        base.extend(::React::FunctionComponent::Creator)
-      end
-    end
-  end
-end

data/lib/react/function_component/resolution.rb

@@ -1,62 +0,0 @@
-module React
-  module FunctionComponent
-    module Resolution
-      def self.included(base)
-        base.instance_exec do
-          alias _react_function_component_resolution_original_const_missing const_missing
-
-          def const_missing(const_name)
-            # language=JS
-            %x{
-              if (typeof Opal.global[const_name] === "object") {
-                var new_const = #{React::NativeConstantWrapper.new(`Opal.global[const_name]`, const_name)};
-                #{Object.const_set(const_name, `new_const`)};
-                return new_const;
-              } else {
-                return #{_react_function_component_resolution_original_const_missing(const_name)};
-              }
-            }
-          end
-        end
-      end
-
-      alias _react_function_component_resolution_original_method_missing method_missing
-
-      def method_missing(component_name, *args, &block)
-        # html tags are defined as methods, so they will not end up here.
-        # first check for native component and render it, we want to be fast for native components
-        # second check for ruby component and render it, they are a bit slower anyway
-        # third pass on method missing
-        # language=JS
-        %x{
-          var component = null;
-          var component_type = typeof Opal.global[component_name];
-          if (component_type === "function" || component_type === "object") {
-            component = Opal.global[component_name];
-          }
-          else {
-            try {
-              var constant = self.$class().$const_get(component_name, true);
-              if (typeof constant.react_component !== 'undefined') {
-                component = constant.react_component;
-              }
-            } catch(err) { component = null; }
-          }
-          if (!component) {
-            try {
-              constant = Opal.Object.$const_get(component_name);
-              if (typeof constant.react_component !== 'undefined') {
-                component = constant.react_component;
-              }
-            } catch(err) { component = null; }
-          }
-          if (component) {
-            return Opal.React.internal_prepare_args_and_render(component, args, block);
-          } else {
-            return #{_react_function_component_resolution_original_method_missing(component_name, *args, block)};
-          }
-        }
-      end
-    end
-  end
-end

data/lib/react/memo_component/base.rb

@@ -1,9 +0,0 @@
-module React
-  module MemoComponent
-    class Base
-      def self.inherited(base)
-        base.include(::React::MemoComponent::Mixin)
-      end
-    end
-  end
-end

data/lib/react/memo_component/creator.rb

@@ -1,32 +0,0 @@
-module React
-  module MemoComponent
-    module Creator
-      def self.extended(base)
-        %x{
-          base.equality_checker = null;
-          base.react_component = Opal.global.React.memo(function(props) {
-            Opal.React.render_buffer.push([]);
-            Opal.React.active_components.push(base);
-            #{base.new(`props`).instance_exec(&`base.function_block`)};
-            Opal.React.active_components.pop();
-            return Opal.React.render_buffer.pop();
-          }, base.equality_checker);
-        }
-
-        def props_are_equal?(&block)
-          %x{
-            base.equality_checker = function (prev_props, next_props) {
-              var prev_ruby_props = Opal.React.Component.Props.$new({props: prev_props});
-              var next_ruby_props = Opal.React.Component.Props.$new({props: next_props});
-              return #{base.new(`{}`).instance_exec(`prev_ruby_props`, `next_ruby_props`, &block)};
-            }
-          }
-        end
-
-        def create_memo(&block)
-          `base.function_block = #{block}`
-        end
-      end
-    end
-  end
-end

data/lib/react/memo_component/mixin.rb

@@ -1,14 +0,0 @@
-module React
-  module MemoComponent
-    module Mixin
-      def self.included(base)
-        base.include(::React::Component::Elements)
-        base.include(::React::Component::Features)
-        base.include(::React::FunctionComponent::API)
-        base.include(::React::FunctionComponent::Resolution)
-        base.extend(::React::FunctionComponent::EventHandler)
-        base.extend(::React::MemoComponent::Creator)
-      end
-    end
-  end
-end

data/lib/react/native_constant_wrapper.rb

@@ -1,26 +0,0 @@
-module React
-  class NativeConstantWrapper
-    include ::Native::Wrapper
-
-    def initialize(native, const_name)
-      @native = native
-      @const_name = const_name
-    end
-
-    def method_missing(name, *args, &block)
-      # language=JS
-      %x{
-        var component = null;
-        var component_type = typeof #@native[name];
-        if (component_type === "function" || component_type === "object") {
-          component = #@native[name];
-        }
-        if (component) {
-          return Opal.React.internal_prepare_args_and_render(component, args, block);
-        } else {
-          #{raise NameError, "No such native Component #@const_name.#{name}"};
-        }
-      }
-    end
-  end
-end

data/lib/react/pure_component/base.rb

@@ -1,9 +0,0 @@
-module React
-  module PureComponent
-    class Base
-      def self.inherited(base)
-        base.include(::React::PureComponent::Mixin)
-      end
-    end
-  end
-end

data/lib/react/pure_component/mixin.rb

@@ -1,18 +0,0 @@
-module React
-  module PureComponent
-    module Mixin
-      def self.included(base)
-        base.include(::Native::Wrapper)
-        base.extend(::React::Component::NativeComponentConstructor)
-        base.extend(::LucidPropDeclaration::Mixin)
-        base.extend(::React::Component::EventHandler)
-        base.include(::React::Component::Elements)
-        base.include(::React::Component::API)
-        base.include(::React::Component::Callbacks)
-        base.include(::React::Component::Initializer)
-        base.include(::React::Component::Features)
-        base.include(::React::Component::Resolution)
-      end
-    end
-  end
-end

data/lib/react/ref.rb

@@ -1,13 +0,0 @@
-module React
-  class Ref
-    include ::Native::Wrapper
-
-    def is_wrapped_ref
-      true
-    end
-
-    def current
-      `Opal.React.native_element_or_component_to_ruby(#@native.current)`
-    end
-  end
-end

data/lib/react/synthetic_event.rb

@@ -1,53 +0,0 @@
-module React
-  class SyntheticEvent
-    include Native::Wrapper
-    # helpers
-    def self.native_accessors(*js_names)
-      js_names.each do |js_name|
-        ruby_name = js_name.underscore
-        define_method(ruby_name) do
-          @native.JS[js_name]
-        end
-      end
-    end
-
-    def self.native_boolean_accessors(*js_names)
-      js_names.each do |js_name|
-        ruby_name = js_name.underscore + '?'
-        define_method(ruby_name) do
-          @native.JS[js_name]
-        end
-      end
-    end
-
-    alias_native :get_modifier_state, :getModifierState
-    alias_native :is_default_prevented?, :isDefaultPrevented
-    alias_native :is_propagation_stopped?, :isPropagationStopped
-    alias_native :persist, :persist
-    alias_native :prevent_default, :preventDefault
-    alias_native :stop_propagation, :stopPropagation
-
-    native_accessors :animationName, :button, :buttons, :changedTouches, :charCode, :clientX, :clientY, :clipboardData, :data, :deltaMode, :deltaX,
-                     :deltaY, :deltaZ, :detail, :elapsedTime, :eventPhase, :height, :key, :keyCode, :locale, :location, :pageX, :pageY, :pointerId,
-                     :pointerType, :pressure, :propertyName, :pseudoElement, :screenX, :screenY, :tangentialPressure, :targetTouches, :tiltX, :tiltY,
-                     :timestamp, :touches, :twist, :type, :view, :which, :width
-
-    native_boolean_accessors :altKey, :bubbles, :cancelable, :ctrlKey, :defaultPrevented, :isPrimary, :isTrusted, :metaKey, :repeat, :shiftKey
-
-    def current_target
-      Browser::Element.new(@native.JS[:currentTarget])
-    end
-
-    def native_event
-      Browser::Event.new(@native.JS[:nativeEvent])
-    end
-
-    def related_target
-      Browser::Element.new(@native.JS[:relatedTarget])
-    end
-
-    def target
-      Browser::Element.new(@native.JS[:target])
-    end
-  end
-end

data/lib/react/version.rb

@@ -1,3 +0,0 @@
-module React
-  VERSION = '16.9.24'
-end

data/lib/react_dom.rb

@@ -1,47 +0,0 @@
-module ReactDOM
-  class << self
-    def create_portal(child, container)
-      # container is a native DOM node
-      `Opal.global.ReactDOM.createPortal(child, container)`
-    end
-
-    def find_dom_node(native_react_component)
-      `Opal.global.ReactDOM.findDOMNode(native_react_component)`
-    end
-
-    def hydrate(native_react_element, container, &block)
-      # container is a native DOM element
-      `Opal.React.render_buffer.push([]);`
-      result = if block_given?
-                 `Opal.global.ReactDOM.hydrate(native_react_element, container, function() { block.$call() })`
-               else
-                 `Opal.global.ReactDOM.hydrate(native_react_element, container)`
-               end
-      `Opal.React.render_buffer.pop()`
-      result
-    end
-
-    def render(native_react_element, container, &block)
-      # container is a native DOM element
-      `Opal.React.render_buffer.push([]);`
-      result = if block_given?
-                 `Opal.global.ReactDOM.render(native_react_element, container, function() { block.$call() })`
-               else
-                 `Opal.global.ReactDOM.render(native_react_element, container)`
-               end
-      `Opal.React.render_buffer.pop()`
-      result
-    end
-
-    def unmount_component_at_node(element_or_query)
-      if `(typeof element_or_query === 'string')` || (`(typeof element_or_query.$class === 'function')` && element_or_query.class == String)
-        element = `document.body.querySelector(element_or_query)`
-      elsif `(typeof element_or_query.$is_a === 'function')` && element_or_query.is_a?(Browser::Element)
-        element = element_or_query.to_n
-      else
-        element = element_or_query
-      end
-      `Opal.global.ReactDOM.unmountComponentAtNode(element)`
-    end
-  end
-end

data/lib/react_dom_server.rb

@@ -1,19 +0,0 @@
-module ReactDOMServer
-  class << self
-    def render_to_string(native_react_element)
-      `Opal.global.ReactDOMServer.renderToString(native_react_element)`
-    end
-
-    def render_to_static_markup(native_react_element)
-      `Opal.global.ReactDOMServer.renderToStaticMarkup(native_react_element)`
-    end
-
-    def render_to_node_stream(native_react_element)
-      `Opal.global.ReactDOMServer.renderToNodeStream(native_react_element)`
-    end
-
-    def render_to_static_node_stream(native_react_element)
-      `Opal.global.ReactDOMServer.renderToStaticNodeStream(native_react_element)`
-    end
-  end
-end