isomorfeus-react 16.13.11 → 16.13.12

data/lib/isomorfeus_react/lucid_component/class_store_proxy.rb

@@ -1,44 +1,44 @@
-module LucidComponent
-  class ClassStoreProxy
-    def initialize(component_name, component_instance = nil, native = nil)
-      @component_name = component_name
-      if component_instance
-        @native = native
-        @component_instance = component_instance
-      end
-    end
-
-    def [](key)
-      method_missing(key)
-    end
-
-    def []=(key, value)
-      method_missing(key, value)
-    end
-
-    def method_missing(key, *args, &block)
-      if `args.length > 0`
-        # set class state, simply a dispatch
-        action = { type: 'CLASS_STATE', class: @component_name, name: (`key.endsWith('=')` ? key.chop : key), value: args[0] }
-        Isomorfeus.store.collect_and_defer_dispatch(action)
-      else
-        # get class state
-        # check if we have a component local state value
-        if @native && @native.JS[:props].JS[:store]
-          if @native.JS[:props].JS[:store].JS[:class_state] &&
-              @native.JS[:props].JS[:store].JS[:class_state].JS[@component_name] &&
-              @native.JS[:props].JS[:store].JS[:class_state].JS[@component_name].JS.hasOwnProperty(key)
-            return @native.JS[:props].JS[:store].JS[:class_state].JS[@component_name].JS[key]
-          end
-        else
-          a_state = Isomorfeus.store.get_state
-          if a_state.key?(:class_state) && a_state[:class_state].key?(@component_name) && a_state[:class_state][@component_name].key?(key)
-            return a_state[:class_state][@component_name][key]
-          end
-        end
-        # otherwise return nil
-        return nil
-      end
-    end
-  end
-end
+module LucidComponent
+  class ClassStoreProxy
+    def initialize(component_name, component_instance = nil, native = nil)
+      @component_name = component_name
+      if component_instance
+        @native = native
+        @component_instance = component_instance
+      end
+    end
+
+    def [](key)
+      method_missing(key)
+    end
+
+    def []=(key, value)
+      method_missing(key, value)
+    end
+
+    def method_missing(key, *args, &block)
+      if `args.length > 0`
+        # set class state, simply a dispatch
+        action = { type: 'CLASS_STATE', class: @component_name, name: (`key.endsWith('=')` ? key.chop : key), value: args[0] }
+        Isomorfeus.store.collect_and_defer_dispatch(action)
+      else
+        # get class state
+        # check if we have a component local state value
+        if @native && @native.JS[:props].JS[:store]
+          if @native.JS[:props].JS[:store].JS[:class_state] &&
+              @native.JS[:props].JS[:store].JS[:class_state].JS[@component_name] &&
+              @native.JS[:props].JS[:store].JS[:class_state].JS[@component_name].JS.hasOwnProperty(key)
+            return @native.JS[:props].JS[:store].JS[:class_state].JS[@component_name].JS[key]
+          end
+        else
+          a_state = Isomorfeus.store.get_state
+          if a_state.key?(:class_state) && a_state[:class_state].key?(@component_name) && a_state[:class_state][@component_name].key?(key)
+            return a_state[:class_state][@component_name][key]
+          end
+        end
+        # otherwise return nil
+        return nil
+      end
+    end
+  end
+end

data/lib/isomorfeus_react/lucid_component/initializer.rb

@@ -1,14 +1,14 @@
-module LucidComponent
-  module Initializer
-    def initialize(native_component)
-      @native = native_component
-      @app_store = LucidComponent::AppStoreProxy.new(self)
-      @class_store = LucidComponent::ClassStoreProxy.new(self.class.to_s, self, @native)
-      # @iso_store = Isomorfeus::IsomorphicStoreProxy.new(self)
-      # @local_store = Isomorfeus::LocalStoreProxy.new(self)
-      @store = LucidComponent::InstanceStoreProxy.new(self)
-      @props = `Opal.React.Component.Props.$new(#@native)`
-      @state = `Opal.React.Component.State.$new(#@native)`
-    end
-  end
-end
+module LucidComponent
+  module Initializer
+    def initialize(native_component)
+      @native = native_component
+      @app_store = LucidComponent::AppStoreProxy.new(self)
+      @class_store = LucidComponent::ClassStoreProxy.new(self.class.to_s, self, @native)
+      # @iso_store = Isomorfeus::IsomorphicStoreProxy.new(self)
+      # @local_store = Isomorfeus::LocalStoreProxy.new(self)
+      @store = LucidComponent::InstanceStoreProxy.new(self)
+      @props = `Opal.React.Component.Props.$new(#@native)`
+      @state = `Opal.React.Component.State.$new(#@native)`
+    end
+  end
+end

data/lib/isomorfeus_react/lucid_component/instance_store_proxy.rb

@@ -1,44 +1,44 @@
-module LucidComponent
-  class InstanceStoreProxy
-    def initialize(component_instance)
-      @native = component_instance.to_n
-      @component_instance = component_instance
-      @component_object_id = component_instance.object_id.to_s
-    end
-
-    def [](key)
-      method_missing(key)
-    end
-
-    def []=(key, value)
-      method_missing(key, value)
-    end
-
-    def method_missing(key, *args, &block)
-      if `args.length > 0`
-        # set instance state, simply a dispatch
-
-        action = { type: 'INSTANCE_STATE', object_id: @component_object_id, name: (`key.endsWith('=')` ? key.chop : key), value: args[0] }
-        Isomorfeus.store.collect_and_defer_dispatch(action)
-
-      else
-        # get instance state
-        if @native.JS[:props].JS[:store]
-          if @native.JS[:props].JS[:store].JS[:instance_state] &&
-              @native.JS[:props].JS[:store].JS[:instance_state].JS[@component_object_id] &&
-              @native.JS[:props].JS[:store].JS[:instance_state].JS[@component_object_id].JS.hasOwnProperty(key)
-            # check if we have a component local state value
-            return @native.JS[:props].JS[:store].JS[:instance_state].JS[@component_object_id].JS[key]
-          end
-        else
-          a_state = Isomorfeus.store.get_state
-          if a_state.key?(:instance_state) && a_state[:instance_state].key?(key)
-            return a_state[:instance_state][key]
-          end
-        end
-        # otherwise return nil
-        return nil
-      end
-    end
-  end
-end
+module LucidComponent
+  class InstanceStoreProxy
+    def initialize(component_instance)
+      @native = component_instance.to_n
+      @component_instance = component_instance
+      @component_object_id = component_instance.object_id.to_s
+    end
+
+    def [](key)
+      method_missing(key)
+    end
+
+    def []=(key, value)
+      method_missing(key, value)
+    end
+
+    def method_missing(key, *args, &block)
+      if `args.length > 0`
+        # set instance state, simply a dispatch
+
+        action = { type: 'INSTANCE_STATE', object_id: @component_object_id, name: (`key.endsWith('=')` ? key.chop : key), value: args[0] }
+        Isomorfeus.store.collect_and_defer_dispatch(action)
+
+      else
+        # get instance state
+        if @native.JS[:props].JS[:store]
+          if @native.JS[:props].JS[:store].JS[:instance_state] &&
+              @native.JS[:props].JS[:store].JS[:instance_state].JS[@component_object_id] &&
+              @native.JS[:props].JS[:store].JS[:instance_state].JS[@component_object_id].JS.hasOwnProperty(key)
+            # check if we have a component local state value
+            return @native.JS[:props].JS[:store].JS[:instance_state].JS[@component_object_id].JS[key]
+          end
+        else
+          a_state = Isomorfeus.store.get_state
+          if a_state.key?(:instance_state) && a_state[:instance_state].key?(key)
+            return a_state[:instance_state][key]
+          end
+        end
+        # otherwise return nil
+        return nil
+      end
+    end
+  end
+end

data/lib/isomorfeus_react/lucid_component/mixin.rb

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

data/lib/isomorfeus_react/lucid_component/native_component_constructor.rb

@@ -1,35 +1,35 @@
-module LucidComponent
-  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 + 'Wrapper'
-      # language=JS
-      %x{
-        base.react_component = Opal.global.React.memo(function(props) {
-          let opag = Opal.global;
-          let classes;
-          let store;
-          if (base.store_updates) { store = opag.React.useContext(opag.LucidApplicationContext); }
-          let theme = opag.ReactJSS.useTheme();
-          if (base.jss_styles) {
-            if (!base.use_styles || (Opal.Isomorfeus.development === true)) {
-              let styles;
-              if (typeof base.jss_styles === 'function') { styles = base.jss_styles(theme); }
-              else { styles = base.jss_styles; }
-              base.use_styles = opag.ReactJSS.createUseStyles(styles);
-            }
-            classes = base.use_styles();
-          }
-          let new_props = Object.assign({}, props)
-          new_props.classes = classes;
-          new_props.theme = theme;
-          new_props.store = store;
-          return opag.React.createElement(base.lucid_react_component, new_props);
-        }, Opal.React.props_are_equal);
-        base.react_component.displayName = #{component_name};
-      }
-    end
-  end
-end
+module LucidComponent
+  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 + 'Wrapper'
+      # language=JS
+      %x{
+        base.react_component = Opal.global.React.memo(function(props) {
+          let opag = Opal.global;
+          let classes;
+          let store;
+          if (base.store_updates) { store = opag.React.useContext(opag.LucidApplicationContext); }
+          let theme = opag.ReactJSS.useTheme();
+          if (base.jss_styles) {
+            if (!base.use_styles || (Opal.Isomorfeus.development === true)) {
+              let styles;
+              if (typeof base.jss_styles === 'function') { styles = base.jss_styles(theme); }
+              else { styles = base.jss_styles; }
+              base.use_styles = opag.ReactJSS.createUseStyles(styles);
+            }
+            classes = base.use_styles();
+          }
+          let new_props = Object.assign({}, props)
+          new_props.classes = classes;
+          new_props.theme = theme;
+          new_props.store = store;
+          return opag.React.createElement(base.lucid_react_component, new_props);
+        }, Opal.React.props_are_equal);
+        base.react_component.displayName = #{component_name};
+      }
+    end
+  end
+end

data/lib/isomorfeus_react/lucid_component/native_lucid_component_constructor.rb

@@ -1,83 +1,82 @@
-module LucidComponent
-  module NativeLucidComponentConstructor
-    # 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.lucid_react_component = class extends Opal.global.React.Component {
-          constructor(props) {
-            super(props);
-            const oper = Opal.React;
-            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 = oper.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();
-              }
-            }
-            if (base.preload_block) {
-              oper.active_redux_components.push(this);
-              this.state.preloaded = this.__ruby_instance.$execute_preload_block();
-              oper.active_redux_components.pop();
-            }
-          }
-          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("lucid component pushed", oper.render_buffer, oper.render_buffer.toString());
-            oper.active_components.push(this);
-            oper.active_redux_components.push(this);
-            let block_result;
-            if (base.while_loading_block && !this.state.preloaded) { block_result = #{`this.__ruby_instance`.instance_exec(&`base.while_loading_block`)}; }
-            else { block_result = #{`this.__ruby_instance`.instance_exec(&`base.render_block`)}; }
-            if (block_result && block_result !== nil) { oper.render_block_result(block_result); }
-            oper.active_redux_components.pop();
-            oper.active_components.pop();
-            // console.log("lucid component popping", oper.render_buffer, oper.render_buffer.toString());
-            let result = oper.render_buffer.pop();
-            return (result.length === 1) ? result[0] : result;
-          }
-          data_access() {
-            return this.props.store;
-          }
-          shouldComponentUpdate(next_props, next_state) {
-            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;
-          }
-        };
-        base.preload_block = null;
-        base.while_loading_block = null;
-        base.jss_styles = null;
-        base.use_styles = null;
-        base.store_updates = true;
-      }
-    end
-  end
-end
+module LucidComponent
+  module NativeLucidComponentConstructor
+    # 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.lucid_react_component = class extends Opal.global.React.Component {
+          constructor(props) {
+            super(props);
+            const oper = Opal.React;
+            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 = oper.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();
+              }
+            }
+            if (base.preload_block) {
+              oper.active_redux_components.push(this);
+              this.state.preloaded = this.__ruby_instance.$execute_preload_block();
+              oper.active_redux_components.pop();
+            }
+          }
+          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("lucid component pushed", oper.render_buffer, oper.render_buffer.toString());
+            oper.active_components.push(this);
+            oper.active_redux_components.push(this);
+            let block_result;
+            if (base.while_loading_block && !this.state.preloaded) { block_result = #{`this.__ruby_instance`.instance_exec(&`base.while_loading_block`)}; }
+            else { block_result = #{`this.__ruby_instance`.instance_exec(&`base.render_block`)}; }
+            if (block_result && block_result !== nil) { oper.render_block_result(block_result); }
+            oper.active_redux_components.pop();
+            oper.active_components.pop();
+            // console.log("lucid component popping", oper.render_buffer, oper.render_buffer.toString());
+            let result = oper.render_buffer.pop();
+            return (result.length === 1) ? result[0] : result;
+          }
+          data_access() {
+            return this.props.store;
+          }
+          shouldComponentUpdate(next_props, next_state) {
+            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;
+          }
+        };
+        base.preload_block = null;
+        base.while_loading_block = null;
+        base.jss_styles = null;
+        base.use_styles = null;
+        base.store_updates = true;
+      }
+    end
+  end
+end

data/lib/isomorfeus_react/lucid_component/styles_api.rb

@@ -1,34 +1,34 @@
-module LucidComponent
-  module StylesApi
-    def self.included(base)
-      base.instance_exec do
-        # styles
-        def styles(styles_hash = nil, &block)
-          if block_given?
-            %x{
-              base.jss_styles = function(theme) {
-                let wrapped_theme = Opal.React.Component.Styles.$new(theme);
-                var result = block.$call(wrapped_theme);
-                return result.$to_n();
-              }
-            }
-            nil
-          elsif styles_hash
-            `base.jss_styles = #{styles_hash.to_n}` if styles_hash
-            styles_hash
-          elsif `typeof base.jss_styles === 'object'`
-            `Opal.Hash.$new(base.jss_styles)`
-          else
-            nil
-          end
-        end
-        alias_method :styles=, :styles
-      end
-
-      # styles
-      def styles
-        props.classes
-      end
-    end
-  end
-end
+module LucidComponent
+  module StylesApi
+    def self.included(base)
+      base.instance_exec do
+        # styles
+        def styles(styles_hash = nil, &block)
+          if block_given?
+            %x{
+              base.jss_styles = function(theme) {
+                let wrapped_theme = Opal.React.Component.Styles.$new(theme);
+                var result = block.$call(wrapped_theme);
+                return result.$to_n();
+              }
+            }
+            nil
+          elsif styles_hash
+            `base.jss_styles = #{styles_hash.to_n}` if styles_hash
+            styles_hash
+          elsif `typeof base.jss_styles === 'object'`
+            `Opal.Hash.$new(base.jss_styles)`
+          else
+            nil
+          end
+        end
+        alias_method :styles=, :styles
+      end
+
+      # styles
+      def styles
+        props.classes
+      end
+    end
+  end
+end

data/lib/isomorfeus_react/lucid_func/base.rb

@@ -1,7 +1,7 @@
-module LucidFunc
-  class Base
-    def self.inherited(base)
-      base.include(::LucidFunc::Mixin)
-    end
-  end
-end
+module LucidFunc
+  class Base
+    def self.inherited(base)
+      base.include(::LucidFunc::Mixin)
+    end
+  end
+end

data/lib/isomorfeus_react/lucid_func/initializer.rb

@@ -1,11 +1,11 @@
-module LucidFunc
-  module Initializer
-    def initialize
-      self.JS[:native_props] = `{ props: null }`
-      @native_props = `Opal.React.Component.Props.$new(#{self})`
-      @app_store = LucidComponent::AppStoreProxy.new(self)
-      @class_store = LucidComponent::ClassStoreProxy.new(self.class.to_s, self, self)
-      @store = LucidComponent::InstanceStoreProxy.new(self)
-    end
-  end
-end
+module LucidFunc
+  module Initializer
+    def initialize
+      self.JS[:native_props] = `{ props: null }`
+      @native_props = `Opal.React.Component.Props.$new(#{self})`
+      @app_store = LucidComponent::AppStoreProxy.new(self)
+      @class_store = LucidComponent::ClassStoreProxy.new(self.class.to_s, self, self)
+      @store = LucidComponent::InstanceStoreProxy.new(self)
+    end
+  end
+end

data/lib/isomorfeus_react/lucid_func/mixin.rb

@@ -1,18 +1,18 @@
-module LucidFunc
-  module Mixin
-    def self.included(base)
-      base.include(::React::Component::Features)
-      base.include(::LucidFunc::Initializer)
-      base.include(::React::FunctionComponent::Api)
-      if on_browser?  || on_ssr?
-        base.extend(::LucidFunc::NativeComponentConstructor)
-        base.include(::React::Component::Elements)
-      elsif on_mobile?
-        base.extend(::LucidFunc::ReactNativeComponentConstructor)
-        base.include(::ReactNative::Component::Elements)
-      end
-      base.include(::LucidComponent::Api)
-      base.include(::LucidComponent::StylesApi)
-    end
-  end
-end
+module LucidFunc
+  module Mixin
+    def self.included(base)
+      base.include(::React::Component::Features)
+      base.include(::LucidFunc::Initializer)
+      base.include(::React::FunctionComponent::Api)
+      if on_browser?  || on_ssr?
+        base.extend(::LucidFunc::NativeComponentConstructor)
+        base.include(::React::Component::Elements)
+      elsif on_mobile?
+        base.extend(::LucidFunc::ReactNativeComponentConstructor)
+        base.include(::ReactNative::Component::Elements)
+      end
+      base.include(::LucidComponent::Api)
+      base.include(::LucidComponent::StylesApi)
+    end
+  end
+end