isomorfeus-react 16.13.11 → 16.13.12

data/lib/isomorfeus_react/lucid_app/mixin.rb

@@ -1,23 +1,23 @@
-module LucidApp
-  module Mixin
-    def self.included(base)
-      base.include(::Native::Wrapper)
-      base.extend(::LucidApp::NativeLucidComponentConstructor)
-      if on_browser? || on_ssr?
-        base.extend(::LucidApp::NativeComponentConstructor)
-        base.include(::React::Component::Elements)
-      elsif on_mobile?
-        base.extend(::LucidApp::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(::LucidApp::Api)
-      base.include(::LucidComponent::Initializer)
-      base.include(::React::Component::Features)
-    end
-  end
-end
+module LucidApp
+  module Mixin
+    def self.included(base)
+      base.include(::Native::Wrapper)
+      base.extend(::LucidApp::NativeLucidComponentConstructor)
+      if on_browser? || on_ssr?
+        base.extend(::LucidApp::NativeComponentConstructor)
+        base.include(::React::Component::Elements)
+      elsif on_mobile?
+        base.extend(::LucidApp::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(::LucidApp::Api)
+      base.include(::LucidComponent::Initializer)
+      base.include(::React::Component::Features)
+    end
+  end
+end

data/lib/isomorfeus_react/lucid_app/native_component_constructor.rb

@@ -1,48 +1,48 @@
-module LucidApp
-  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)
-      theme_component_name = base.to_s + 'ThemeWrapper'
-      # language=JS
-      %x{
-        base.jss_theme = {};
-        base.themed_react_component = function(props) {
-          let opag = Opal.global;
-          let classes = null;
-          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 themed_classes_props = Object.assign({}, props, { classes: classes, theme: theme });
-          return opag.React.createElement(base.lucid_react_component, themed_classes_props);
-        };
-        base.themed_react_component.displayName = #{theme_component_name};
-        base.react_component = class extends Opal.global.React.Component {
-          constructor(props) {
-            super(props);
-            if (Opal.Isomorfeus.$top_component() == nil) { Opal.Isomorfeus['$top_component='](this); }
-          }
-          static get displayName() {
-            return "IsomorfeusTopLevelComponent";
-          }
-          static set displayName(new_name) {
-            // dont do anything here except returning the set value
-            return new_name;
-          }
-          render() {
-            let themed_component = Opal.global.React.createElement(base.themed_react_component, this.props);
-            return Opal.global.React.createElement(Opal.global.ReactJSS.ThemeProvider, { theme: base.jss_theme }, themed_component);
-          }
-        }
-      }
-    end
-  end
-end
+module LucidApp
+  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)
+      theme_component_name = base.to_s + 'ThemeWrapper'
+      # language=JS
+      %x{
+        base.jss_theme = {};
+        base.themed_react_component = function(props) {
+          let opag = Opal.global;
+          let classes = null;
+          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 themed_classes_props = Object.assign({}, props, { classes: classes, theme: theme });
+          return opag.React.createElement(base.lucid_react_component, themed_classes_props);
+        };
+        base.themed_react_component.displayName = #{theme_component_name};
+        base.react_component = class extends Opal.global.React.Component {
+          constructor(props) {
+            super(props);
+            if (Opal.Isomorfeus.$top_component() == nil) { Opal.Isomorfeus['$top_component='](this); }
+          }
+          static get displayName() {
+            return "IsomorfeusTopLevelComponent";
+          }
+          static set displayName(new_name) {
+            // dont do anything here except returning the set value
+            return new_name;
+          }
+          render() {
+            let themed_component = Opal.global.React.createElement(base.themed_react_component, this.props);
+            return Opal.global.React.createElement(Opal.global.ReactJSS.ThemeProvider, { theme: base.jss_theme }, themed_component);
+          }
+        }
+      }
+    end
+  end
+end

data/lib/isomorfeus_react/lucid_app/native_lucid_component_constructor.rb

@@ -1,95 +1,94 @@
-module LucidApp
-  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.state.isomorfeus_store_state = Opal.Isomorfeus.store.native.getState();
-            var current_store_state = this.state.isomorfeus_store_state;
-            if (typeof current_store_state.class_state[#{component_name}] !== "undefined") {
-              this.state.class_state = {};
-              this.state.class_state[#{component_name}] = current_store_state.class_state[#{component_name}];
-            } else {
-              this.state.class_state = {};
-              this.state.class_state[#{component_name}] = {};
-            };
-            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();
-            }
-            this.listener = this.listener.bind(this);
-            this.unsubscriber = Opal.Isomorfeus.store.native.subscribe(this.listener);
-          }
-          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 app 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();
-            let children = oper.render_buffer.pop();
-            // console.log("lucid app popping", oper.render_buffer, oper.render_buffer.toString());
-            return Opal.global.React.createElement.apply(this, [Opal.global.LucidApplicationContext.Provider, { value: this.state.isomorfeus_store_state }].concat(children));
-          }
-          data_access() {
-            this.state.isomorfeus_store_state;
-          }
-          listener() {
-            let next_state = Opal.Isomorfeus.store.native.getState();
-            this.setState({ isomorfeus_store_state: next_state });
-          }
-          componentWillUnmount() {
-            if (typeof this.unsubscriber === "function") { this.unsubscriber(); }
-          }
-          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;
-      }
-    end
-  end
-end
+module LucidApp
+  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.state.isomorfeus_store_state = Opal.Isomorfeus.store.native.getState();
+            var current_store_state = this.state.isomorfeus_store_state;
+            if (typeof current_store_state.class_state[#{component_name}] !== "undefined") {
+              this.state.class_state = {};
+              this.state.class_state[#{component_name}] = current_store_state.class_state[#{component_name}];
+            } else {
+              this.state.class_state = {};
+              this.state.class_state[#{component_name}] = {};
+            };
+            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();
+            }
+            this.listener = this.listener.bind(this);
+            this.unsubscriber = Opal.Isomorfeus.store.native.subscribe(this.listener);
+          }
+          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 app 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();
+            let children = oper.render_buffer.pop();
+            // console.log("lucid app popping", oper.render_buffer, oper.render_buffer.toString());
+            return Opal.global.React.createElement.apply(this, [Opal.global.LucidApplicationContext.Provider, { value: this.state.isomorfeus_store_state }].concat(children));
+          }
+          data_access() {
+            this.state.isomorfeus_store_state;
+          }
+          listener() {
+            let next_state = Opal.Isomorfeus.store.native.getState();
+            this.setState({ isomorfeus_store_state: next_state });
+          }
+          componentWillUnmount() {
+            if (typeof this.unsubscriber === "function") { this.unsubscriber(); }
+          }
+          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;
+      }
+    end
+  end
+end

data/lib/isomorfeus_react/lucid_component/api.rb

@@ -1,75 +1,75 @@
-module LucidComponent
-  module Api
-    def self.included(base)
-      base.instance_exec do
-        # store
-        attr_accessor :app_store
-        attr_accessor :class_store
-        attr_accessor :store
-
-        def class_store
-          @class_store ||= ::LucidComponent::ClassStoreProxy.new(self.to_s)
-        end
-
-        def store_updates(switch)
-          case switch
-          when :on then `base.store_updates = true`
-          when :off then `base.store_updates = false`
-          end
-        end
-
-        # preloading
-        def preload(&block)
-          `base.preload_block = block`
-          component_did_mount do
-            unless self.state.preloaded
-              @_preload_promise.then { self.state.preloaded = true }.fail do |result|
-                err_text = "#{self.class.name}: preloading failed, last result: #{result.nil? ? 'nil' : result}!"
-                `console.error(err_text)`
-              end
-            end
-          end
-        end
-
-        def while_loading(option = nil, &block)
-          wl_block = proc do
-            if @_preload_promise.resolved?
-              instance_exec(&`base.render_block`)
-            else
-              instance_exec(&block)
-            end
-          end
-          `base.while_loading_block = wl_block`
-        end
-      end
-
-      # stores
-      def local_store
-        LocalStore
-      end
-
-      def session_store
-        SessionStore
-      end
-
-      def theme
-        props.theme
-      end
-
-      # preloading
-      def execute_preload_block
-        @_preload_promise = instance_exec(&self.class.JS[:preload_block])
-        @_preload_promise.resolved?
-      end
-
-      def preloaded?
-        !!state.preloaded
-      end
-
-      # requires transport
-      def current_user
-        Isomorfeus.current_user
-      end
-    end
-  end
-end
+module LucidComponent
+  module Api
+    def self.included(base)
+      base.instance_exec do
+        # store
+        attr_accessor :app_store
+        attr_accessor :class_store
+        attr_accessor :store
+
+        def class_store
+          @class_store ||= ::LucidComponent::ClassStoreProxy.new(self.to_s)
+        end
+
+        def store_updates(switch)
+          case switch
+          when :on then `base.store_updates = true`
+          when :off then `base.store_updates = false`
+          end
+        end
+
+        # preloading
+        def preload(&block)
+          `base.preload_block = block`
+          component_did_mount do
+            unless self.state.preloaded
+              @_preload_promise.then { self.state.preloaded = true }.fail do |result|
+                err_text = "#{self.class.name}: preloading failed, last result: #{result.nil? ? 'nil' : result}!"
+                `console.error(err_text)`
+              end
+            end
+          end
+        end
+
+        def while_loading(option = nil, &block)
+          wl_block = proc do
+            if @_preload_promise.resolved?
+              instance_exec(&`base.render_block`)
+            else
+              instance_exec(&block)
+            end
+          end
+          `base.while_loading_block = wl_block`
+        end
+      end
+
+      # stores
+      def local_store
+        LocalStore
+      end
+
+      def session_store
+        SessionStore
+      end
+
+      def theme
+        props.theme
+      end
+
+      # preloading
+      def execute_preload_block
+        @_preload_promise = instance_exec(&self.class.JS[:preload_block])
+        @_preload_promise.resolved?
+      end
+
+      def preloaded?
+        !!state.preloaded
+      end
+
+      # requires transport
+      def current_user
+        Isomorfeus.current_user
+      end
+    end
+  end
+end

data/lib/isomorfeus_react/lucid_component/app_store_proxy.rb

@@ -1,37 +1,37 @@
-module LucidComponent
-  class AppStoreProxy
-    def initialize(component_instance)
-      if component_instance
-        @native = component_instance.to_n
-        @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: 'APPLICATION_STATE', name: (`key.endsWith('=')` ? key.chop : key), value: args[0] }
-        Isomorfeus.store.collect_and_defer_dispatch(action)
-      else
-        # check if we have a component local state value
-        if @native && `#@native.props.store`
-          if `#@native.props.store.application_state && #@native.props.store.application_state.hasOwnProperty(key)`
-            return @native.JS[:props].JS[:store].JS[:application_state].JS[key]
-          end
-        else
-          return AppStore[key]
-        end
-        # otherwise return nil
-        return nil
-      end
-    end
-  end
-end
+module LucidComponent
+  class AppStoreProxy
+    def initialize(component_instance)
+      if component_instance
+        @native = component_instance.to_n
+        @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: 'APPLICATION_STATE', name: (`key.endsWith('=')` ? key.chop : key), value: args[0] }
+        Isomorfeus.store.collect_and_defer_dispatch(action)
+      else
+        # check if we have a component local state value
+        if @native && `#@native.props.store`
+          if `#@native.props.store.application_state && #@native.props.store.application_state.hasOwnProperty(key)`
+            return @native.JS[:props].JS[:store].JS[:application_state].JS[key]
+          end
+        else
+          return AppStore[key]
+        end
+        # otherwise return nil
+        return nil
+      end
+    end
+  end
+end

data/lib/isomorfeus_react/lucid_component/base.rb

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