isomorfeus-react 16.13.11 → 16.13.12

data/lib/react/component/match.rb

@@ -1,31 +1,35 @@
-module React
-  module Component
-    class Match
-      include ::Native::Wrapper
-
-      def method_missing(prop, *args, &block)
-        @native.JS[:props].JS[:match].JS[:params].JS[prop]
-      end
-
-      def is_exact
-        @native.JS[:props].JS[:match].JS[:isExact]
-      end
-
-      def params
-        self
-      end
-
-      def path
-        @native.JS[:props].JS[:match].JS[:path]
-      end
-
-      def url
-        @native.JS[:props].JS[:match].JS[:url]
-      end
-
-      def to_n
-        @native.JS[:props].JS[:match]
-      end
-    end
-  end
-end
+module React
+  module Component
+    class Match
+      include ::Native::Wrapper
+
+      def initialize(native)
+        @native = native
+      end
+
+      def method_missing(prop, *args, &block)
+        @native.JS[:props].JS[:match].JS[:params].JS[prop]
+      end
+
+      def is_exact
+        @native.JS[:props].JS[:match].JS[:isExact]
+      end
+
+      def params
+        self
+      end
+
+      def path
+        @native.JS[:props].JS[:match].JS[:path]
+      end
+
+      def url
+        @native.JS[:props].JS[:match].JS[:url]
+      end
+
+      def to_n
+        @native.JS[:props].JS[:match]
+      end
+    end
+  end
+end

data/lib/react/component/mixin.rb

@@ -1,20 +1,20 @@
-module React
-  module Component
-    module Mixin
-      def self.included(base)
-        base.include(::Native::Wrapper)
-        base.extend(::React::Component::NativeComponentConstructor)
-        base.extend(::LucidPropDeclaration::Mixin)
-        if on_browser? || on_ssr?
-          base.include(::React::Component::Elements)
-        elsif on_mobile?
-          base.include(::ReactNative::Component::Elements)
-        end
-        base.include(::React::Component::Api)
-        base.include(::React::Component::Callbacks)
-        base.include(::React::Component::Initializer)
-        base.include(::React::Component::Features)
-      end
-    end
-  end
-end
+module React
+  module Component
+    module Mixin
+      def self.included(base)
+        base.include(::Native::Wrapper)
+        base.extend(::React::Component::NativeComponentConstructor)
+        base.extend(::LucidPropDeclaration::Mixin)
+        if on_browser? || on_ssr?
+          base.include(::React::Component::Elements)
+        elsif on_mobile?
+          base.include(::ReactNative::Component::Elements)
+        end
+        base.include(::React::Component::Api)
+        base.include(::React::Component::Callbacks)
+        base.include(::React::Component::Initializer)
+        base.include(::React::Component::Features)
+      end
+    end
+  end
+end

data/lib/react/component/native_component_constructor.rb

@@ -1,70 +1,69 @@
-module React
-  module Component
-    module NativeComponentConstructor
-      # for should_component_update we apply ruby semantics for comparing props
-      # to do so, we convert the props to ruby hashes and then compare
-      # this makes sure, that for example rubys Nil object gets handled properly
-      def self.extended(base)
-        component_name = base.to_s
-        # language=JS
-        %x{
-          base.react_component = class extends Opal.global.React.Component {
-            constructor(props) {
-              super(props);
-              if (base.$default_state_defined()) {
-                this.state = base.$state().$to_n();
-              } else {
-                this.state = {};
-              };
-              this.__ruby_instance = base.$new(this);
-              var defined_refs = #{base.defined_refs};
-              for (var ref in defined_refs) {
-                if (defined_refs[ref] != null) {
-                  this[ref] = function(element) {
-                    element = Opal.React.native_element_or_component_to_ruby(element);
-                    #{`this.__ruby_instance`.instance_exec(`element`, &`defined_refs[ref]`)}
-                  }
-                  this[ref] = this[ref].bind(this);
-                } else {
-                  this[ref] = Opal.global.React.createRef();
-                }
-              }
-            }
-            static get displayName() {
-              return #{component_name};
-            }
-            static set displayName(new_name) {
-              // dont do anything here except returning the set value
-              return new_name;
-            }
-            render() {
-              const oper = Opal.React;
-              oper.render_buffer.push([]);
-              // console.log("react component pushed", oper.render_buffer, oper.render_buffer.toString());
-              oper.active_components.push(this);
-              let block_result = #{`this.__ruby_instance`.instance_exec(&`base.render_block`)};
-              if (block_result && block_result !== nil) { oper.render_block_result(block_result); }
-              // console.log("react component popping", oper.render_buffer, oper.render_buffer.toString());
-              oper.active_components.pop();
-              let result = oper.render_buffer.pop();
-              return (result.length === 1) ? result[0] : result;
-            }
-            shouldComponentUpdate(next_props, next_state) {
-              if (base.should_component_update_block) {
-                return #{!!`this.__ruby_instance`.instance_exec(React::Component::Props.new(`{props: next_props}`), React::Component::State.new(`{state: next_state }`), &`base.should_component_update_block`)};
-              }
-              if (!Opal.React.props_are_equal(this.props, next_props)) { return true; }
-              if (Opal.React.state_is_not_equal(this.state, next_state)) { return true; }
-              return false;
-            }
-            validateProp(props, propName, componentName) {
-              try { base.$validate_prop(propName, props[propName]) }
-              catch (e) { return new Error(componentName + " Error: prop validation failed: " + e.message); }
-              return null;
-            }
-          }
-        }
-      end
-    end
-  end
-end
+module React
+  module Component
+    module NativeComponentConstructor
+      # for should_component_update we apply ruby semantics for comparing props
+      # to do so, we convert the props to ruby hashes and then compare
+      # this makes sure, that for example rubys Nil object gets handled properly
+      def self.extended(base)
+        component_name = base.to_s
+        %x{
+          base.react_component = class extends Opal.global.React.Component {
+            constructor(props) {
+              super(props);
+              if (base.$default_state_defined()) {
+                this.state = base.$state().$to_n();
+              } else {
+                this.state = {};
+              };
+              this.__ruby_instance = base.$new(this);
+              var defined_refs = #{base.defined_refs};
+              for (var ref in defined_refs) {
+                if (defined_refs[ref] != null) {
+                  this[ref] = function(element) {
+                    element = Opal.React.native_element_or_component_to_ruby(element);
+                    #{`this.__ruby_instance`.instance_exec(`element`, &`defined_refs[ref]`)}
+                  }
+                  this[ref] = this[ref].bind(this);
+                } else {
+                  this[ref] = Opal.global.React.createRef();
+                }
+              }
+            }
+            static get displayName() {
+              return #{component_name};
+            }
+            static set displayName(new_name) {
+              // dont do anything here except returning the set value
+              return new_name;
+            }
+            render() {
+              const oper = Opal.React;
+              oper.render_buffer.push([]);
+              // console.log("react component pushed", oper.render_buffer, oper.render_buffer.toString());
+              oper.active_components.push(this);
+              let block_result = #{`this.__ruby_instance`.instance_exec(&`base.render_block`)};
+              if (block_result && block_result !== nil) { oper.render_block_result(block_result); }
+              // console.log("react component popping", oper.render_buffer, oper.render_buffer.toString());
+              oper.active_components.pop();
+              let result = oper.render_buffer.pop();
+              return (result.length === 1) ? result[0] : result;
+            }
+            shouldComponentUpdate(next_props, next_state) {
+              if (base.should_component_update_block) {
+                return #{!!`this.__ruby_instance`.instance_exec(React::Component::Props.new(`{props: next_props}`), React::Component::State.new(`{state: next_state }`), &`base.should_component_update_block`)};
+              }
+              if (!Opal.React.props_are_equal(this.props, next_props)) { return true; }
+              if (Opal.React.state_is_not_equal(this.state, next_state)) { return true; }
+              return false;
+            }
+            validateProp(props, propName, componentName) {
+              try { base.$validate_prop(propName, props[propName]) }
+              catch (e) { return new Error(componentName + " Error: prop validation failed: " + e.message); }
+              return null;
+            }
+          }
+        }
+      end
+    end
+  end
+end

data/lib/react/component/props.rb

@@ -1,83 +1,83 @@
-module React
-  module Component
-    class Props
-      def initialize(native)
-        @native = native
-      end
-
-      def method_missing(prop, *args, &block)
-        %x{
-          const p = #@native.props;
-          if (typeof p[prop] === 'undefined') {
-            prop = Opal.React.lower_camelize(prop);
-            if (typeof p[prop] === 'undefined') { return nil; }
-          }
-          return p[prop];
-        }
-      end
-
-      def classes
-        @classes ||= React::Component::Styles.new(@native, 'classes')
-      end
-
-      def children
-        @native.JS[:props].JS[:children]
-      end
-
-      def theme
-        @theme ||= React::Component::Styles.new(@native, 'theme')
-      end
-
-      def isomorfeus_store
-        @native.JS[:props].JS[:isomorfeus_store]
-      end
-
-      # for router convenience
-      def history
-        return @history if @history
-        return nil if `typeof #@native.props.history === 'undefined'`
-        if `typeof #@native.props.history.action !== 'undefined'`
-          @history = React::Component::History.new(@native)
-        else
-          @native.JS[:props].JS[:history]
-        end
-      end
-
-      def location
-        return @location if @location
-        return nil if `typeof #@native.props.location === 'undefined'`
-        if `typeof #@native.props.location.pathname !== 'undefined'`
-          @location = React::Component::Location.new(@native)
-        else
-          @native.JS[:props].JS[:location]
-        end
-      end
-
-      def match
-        return @match if @match
-        return nil if `typeof #@native.props.match === 'undefined'`
-        if `typeof #@native.props.match.path !== 'undefined'`
-          @match = React::Component::Match.new(@native)
-        else
-          @native.JS[:props].JS[:match]
-        end
-      end
-
-      def to_h
-        `Opal.Hash.$new(#@native.props)`.transform_keys!(&:underscore)
-      end
-
-      def to_json
-        JSON.dump(to_transport)
-      end
-
-      def to_n
-        @native.JS[:props]
-      end
-
-      def to_transport
-        {}.merge(to_h)
-      end
-    end
-  end
-end
+module React
+  module Component
+    class Props
+      def initialize(native)
+        @native = native
+      end
+
+      def method_missing(prop, *args, &block)
+        %x{
+          const p = #@native.props;
+          if (typeof p[prop] === 'undefined') {
+            prop = Opal.React.lower_camelize(prop);
+            if (typeof p[prop] === 'undefined') { return nil; }
+          }
+          return p[prop];
+        }
+      end
+
+      def classes
+        @classes ||= React::Component::Styles.new(@native, 'classes')
+      end
+
+      def children
+        @native.JS[:props].JS[:children]
+      end
+
+      def theme
+        @theme ||= React::Component::Styles.new(@native, 'theme')
+      end
+
+      def isomorfeus_store
+        @native.JS[:props].JS[:isomorfeus_store]
+      end
+
+      # for router convenience
+      def history
+        return @history if @history
+        return nil if `typeof #@native.props.history === 'undefined'`
+        if `typeof #@native.props.history.action !== 'undefined'`
+          @history = React::Component::History.new(@native)
+        else
+          @native.JS[:props].JS[:history]
+        end
+      end
+
+      def location
+        return @location if @location
+        return nil if `typeof #@native.props.location === 'undefined'`
+        if `typeof #@native.props.location.pathname !== 'undefined'`
+          @location = React::Component::Location.new(@native)
+        else
+          @native.JS[:props].JS[:location]
+        end
+      end
+
+      def match
+        return @match if @match
+        return nil if `typeof #@native.props.match === 'undefined'`
+        if `typeof #@native.props.match.path !== 'undefined'`
+          @match = React::Component::Match.new(@native)
+        else
+          @native.JS[:props].JS[:match]
+        end
+      end
+
+      def to_h
+        `Opal.Hash.$new(#@native.props)`.transform_keys!(&:underscore)
+      end
+
+      def to_json
+        JSON.dump(to_transport)
+      end
+
+      def to_n
+        @native.JS[:props]
+      end
+
+      def to_transport
+        {}.merge(to_h)
+      end
+    end
+  end
+end

data/lib/react/component/resolution.rb

@@ -1,97 +1,97 @@
-module React
-  module Component
-    module Resolution
-      def self.included(base)
-        base.instance_exec do
-          unless method_defined?(:_react_component_class_resolution_original_const_missing)
-            alias _react_component_class_resolution_original_const_missing const_missing
-          end
-
-          def const_missing(const_name)
-            %x{
-              if (typeof Opal.global[const_name] !== "undefined" && (const_name[0] === const_name[0].toUpperCase())) {
-                var new_const = #{React::NativeConstantWrapper.new(`Opal.global[const_name]`, const_name)};
-                new_const.react_component = Opal.global[const_name];
-                #{Object.const_set(const_name, `new_const`)};
-                return new_const;
-              } else {
-                return #{_react_component_class_resolution_original_const_missing(const_name)};
-              }
-            }
-          end
-
-          # this is required for autoloading support, as the component may not be loaded and so its method is not registered.
-          # must load it first, done by const_get, and next time the method will be there.
-          unless method_defined?(:_react_component_class_resolution_original_method_missing)
-            alias _react_component_class_resolution_original_method_missing method_missing
-          end
-
-          def method_missing(component_name, *args, &block)
-            # check for ruby component and render it
-            # otherwise pass on method missing
-            %x{
-              var constant;
-              if (typeof self.iso_react_const_cache === 'undefined') { self.iso_react_const_cache = {}; }
-              try {
-                if (typeof self.iso_react_const_cache[component_name] !== 'undefined') {
-                  constant = self.iso_react_const_cache[component_name]
-                } else {
-                  constant = self.$const_get(component_name);
-                  self.iso_react_const_cache[component_name] = constant;
-                }
-                if (typeof constant.react_component !== 'undefined') {
-                  return Opal.React.internal_prepare_args_and_render(constant.react_component, args, block);
-                }
-              } catch(err) { }
-              return #{_react_component_class_resolution_original_method_missing(component_name, *args, block)};
-            }
-          end
-        end
-      end
-
-      unless method_defined?(:_react_component_resolution_original_method_missing)
-        alias _react_component_resolution_original_method_missing method_missing
-      end
-
-      def method_missing(component_name, *args, &block)
-        # Further on it must check for modules, because $const_get does not take
-        # the full nesting into account, as usually its called via $$ with the
-        # nesting provided by the compiler.
-        %x{
-          var constant;
-          if (typeof self.iso_react_const_cache === 'undefined') { self.iso_react_const_cache = {}; }
-
-          if (typeof self.iso_react_const_cache[component_name] !== 'undefined') {
-            constant = self.iso_react_const_cache[component_name]
-          } else if (typeof self.$$is_a_module !== 'undefined') {
-            try {
-              constant = self.$const_get(component_name);
-              self.iso_react_const_cache[component_name] = constant;
-            } catch(err) { }
-          } else {
-            let sc = self.$class();
-            try {
-              constant = sc.$const_get(component_name);
-              self.iso_react_const_cache[component_name] = constant;
-            } catch(err) {
-              var module_names = sc.$to_s().split("::");
-              var module_name;
-              for (var i = module_names.length - 1; i > 0; i--) {
-                module_name = module_names.slice(0, i).join('::');
-                try {
-                  constant = sc.$const_get(module_name).$const_get(component_name, false);
-                  self.iso_react_const_cache[component_name] = constant;
-                  break;
-                } catch(err) { }
-              }
-            }
-          }
-          if (constant && typeof constant.react_component !== 'undefined') {
-            return Opal.React.internal_prepare_args_and_render(constant.react_component, args, block);
-          }
-          return #{_react_component_resolution_original_method_missing(component_name, *args, block)};
-        }
-      end
-    end
-  end
-end
+module React
+  module Component
+    module Resolution
+      def self.included(base)
+        base.instance_exec do
+          unless method_defined?(:_react_component_class_resolution_original_const_missing)
+            alias _react_component_class_resolution_original_const_missing const_missing
+          end
+
+          def const_missing(const_name)
+            %x{
+              if (typeof Opal.global[const_name] !== "undefined" && (const_name[0] === const_name[0].toUpperCase())) {
+                var new_const = #{React::NativeConstantWrapper.new(`Opal.global[const_name]`, const_name)};
+                new_const.react_component = Opal.global[const_name];
+                #{Object.const_set(const_name, `new_const`)};
+                return new_const;
+              } else {
+                return #{_react_component_class_resolution_original_const_missing(const_name)};
+              }
+            }
+          end
+
+          # this is required for autoloading support, as the component may not be loaded and so its method is not registered.
+          # must load it first, done by const_get, and next time the method will be there.
+          unless method_defined?(:_react_component_class_resolution_original_method_missing)
+            alias _react_component_class_resolution_original_method_missing method_missing
+          end
+
+          def method_missing(component_name, *args, &block)
+            # check for ruby component and render it
+            # otherwise pass on method missing
+            %x{
+              var constant;
+              if (typeof self.iso_react_const_cache === 'undefined') { self.iso_react_const_cache = {}; }
+              try {
+                if (typeof self.iso_react_const_cache[component_name] !== 'undefined') {
+                  constant = self.iso_react_const_cache[component_name]
+                } else {
+                  constant = self.$const_get(component_name);
+                  self.iso_react_const_cache[component_name] = constant;
+                }
+                if (typeof constant.react_component !== 'undefined') {
+                  return Opal.React.internal_prepare_args_and_render(constant.react_component, args, block);
+                }
+              } catch(err) { }
+              return #{_react_component_class_resolution_original_method_missing(component_name, *args, block)};
+            }
+          end
+        end
+      end
+
+      unless method_defined?(:_react_component_resolution_original_method_missing)
+        alias _react_component_resolution_original_method_missing method_missing
+      end
+
+      def method_missing(component_name, *args, &block)
+        # Further on it must check for modules, because $const_get does not take
+        # the full nesting into account, as usually its called via $$ with the
+        # nesting provided by the compiler.
+        %x{
+          var constant;
+          if (typeof self.iso_react_const_cache === 'undefined') { self.iso_react_const_cache = {}; }
+
+          if (typeof self.iso_react_const_cache[component_name] !== 'undefined') {
+            constant = self.iso_react_const_cache[component_name]
+          } else if (typeof self.$$is_a_module !== 'undefined') {
+            try {
+              constant = self.$const_get(component_name);
+              self.iso_react_const_cache[component_name] = constant;
+            } catch(err) { }
+          } else {
+            let sc = self.$class();
+            try {
+              constant = sc.$const_get(component_name);
+              self.iso_react_const_cache[component_name] = constant;
+            } catch(err) {
+              var module_names = sc.$to_s().split("::");
+              var module_name;
+              for (var i = module_names.length - 1; i > 0; i--) {
+                module_name = module_names.slice(0, i).join('::');
+                try {
+                  constant = sc.$const_get(module_name).$const_get(component_name, false);
+                  self.iso_react_const_cache[component_name] = constant;
+                  break;
+                } catch(err) { }
+              }
+            }
+          }
+          if (constant && typeof constant.react_component !== 'undefined') {
+            return Opal.React.internal_prepare_args_and_render(constant.react_component, args, block);
+          }
+          return #{_react_component_resolution_original_method_missing(component_name, *args, block)};
+        }
+      end
+    end
+  end
+end