isomorfeus-react 16.13.11 → 16.13.12

data/lib/isomorfeus_react/react/memo_component/native_component_constructor.rb

@@ -1,49 +1,49 @@
-module React
-  module MemoComponent
-    module NativeComponentConstructor
-      def self.extended(base)
-        component_name = base.to_s
-        %x{
-          base.instance_init = function(initial) {
-            let ruby_state = { instance: #{base.new(`{}`)} };
-            ruby_state.instance.__ruby_instance = ruby_state.instance;
-            return ruby_state;
-          }
-          base.instance_reducer = function(state, action) { return state; }
-          base.equality_checker = null;
-          base.react_component = Opal.global.React.memo(function(props) {
-            const oper = Opal.React;
-            oper.render_buffer.push([]);
-            // console.log("memo pushed", oper.render_buffer, oper.render_buffer.toString());
-            const [__ruby_state, __ruby_dispatch] = Opal.global.React.useReducer(base.instance_reducer, null, base.instance_init);
-            const __ruby_instance = __ruby_state.instance;
-            __ruby_instance.props = props;
-            oper.active_components.push(__ruby_instance);
-            let block_result = #{`__ruby_instance`.instance_exec(&`base.render_block`)};
-            if (block_result && block_result !== nil) { oper.render_block_result(block_result); }
-            oper.active_components.pop();
-            // console.log("memo popping", oper.render_buffer, oper.render_buffer.toString());
-            let result = oper.render_buffer.pop();
-            return (result.length === 1) ? result[0] : result;
-          }, base.equality_checker);
-          base.react_component.displayName = #{component_name};
-        }
-
-        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 render(&block)
-          `base.render_block = #{block}`
-        end
-      end
-    end
-  end
-end
+module React
+  module MemoComponent
+    module NativeComponentConstructor
+      def self.extended(base)
+        component_name = base.to_s
+        %x{
+          base.instance_init = function(initial) {
+            let ruby_state = { instance: #{base.new(`{}`)} };
+            ruby_state.instance.__ruby_instance = ruby_state.instance;
+            return ruby_state;
+          }
+          base.instance_reducer = function(state, action) { return state; }
+          base.equality_checker = null;
+          base.react_component = Opal.global.React.memo(function(props) {
+            const oper = Opal.React;
+            oper.render_buffer.push([]);
+            // console.log("memo pushed", oper.render_buffer, oper.render_buffer.toString());
+            const [__ruby_state, __ruby_dispatch] = Opal.global.React.useReducer(base.instance_reducer, null, base.instance_init);
+            const __ruby_instance = __ruby_state.instance;
+            __ruby_instance.props = props;
+            oper.active_components.push(__ruby_instance);
+            let block_result = #{`__ruby_instance`.instance_exec(&`base.render_block`)};
+            if (block_result && block_result !== nil) { oper.render_block_result(block_result); }
+            oper.active_components.pop();
+            // console.log("memo popping", oper.render_buffer, oper.render_buffer.toString());
+            let result = oper.render_buffer.pop();
+            return (result.length === 1) ? result[0] : result;
+          }, base.equality_checker);
+          base.react_component.displayName = #{component_name};
+        }
+
+        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 render(&block)
+          `base.render_block = #{block}`
+        end
+      end
+    end
+  end
+end

data/lib/isomorfeus_react_material/lucid_material/app/base.rb

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

data/lib/isomorfeus_react_material/lucid_material/app/mixin.rb

@@ -1,20 +1,20 @@
-module LucidMaterial
-  module App
-    module Mixin
-      def self.included(base)
-        base.include(::Native::Wrapper)
-        base.extend(::LucidApp::NativeLucidComponentConstructor)
-        base.extend(::LucidMaterial::App::NativeComponentConstructor)
-        base.extend(::LucidPropDeclaration::Mixin)
-        base.include(::React::Component::Elements)
-        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
-end
+module LucidMaterial
+  module App
+    module Mixin
+      def self.included(base)
+        base.include(::Native::Wrapper)
+        base.extend(::LucidApp::NativeLucidComponentConstructor)
+        base.extend(::LucidMaterial::App::NativeComponentConstructor)
+        base.extend(::LucidPropDeclaration::Mixin)
+        base.include(::React::Component::Elements)
+        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
+end

data/lib/isomorfeus_react_material/lucid_material/app/native_component_constructor.rb

@@ -1,50 +1,50 @@
-module LucidMaterial
-  module App
-    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 = Opal.global.Mui.createMuiTheme();
-          base.themed_react_component = function(props) {
-            let opag = Opal.global;
-            let classes = null;
-            let theme = opag.MuiStyles.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.MuiStyles.makeStyles(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.MuiStyles.ThemeProvider, { theme: base.jss_theme }, themed_component);
-            }
-          }
-        }
-      end
-    end
-  end
-end
+module LucidMaterial
+  module App
+    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 = Opal.global.Mui.createTheme();
+          base.themed_react_component = function(props) {
+            let opag = Opal.global;
+            let classes = null;
+            let theme = opag.MuiStyles.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.MuiStyles.makeStyles(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.MuiStyles.ThemeProvider, { theme: base.jss_theme }, themed_component);
+            }
+          }
+        }
+      end
+    end
+  end
+end

data/lib/isomorfeus_react_material/lucid_material/component/base.rb

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

data/lib/isomorfeus_react_material/lucid_material/component/mixin.rb

@@ -1,19 +1,19 @@
-module LucidMaterial
-  module Component
-    module Mixin
-      def self.included(base)
-        base.include(::Native::Wrapper)
-        base.extend(::LucidComponent::NativeLucidComponentConstructor)
-        base.extend(::LucidMaterial::Component::NativeComponentConstructor)
-        base.extend(::LucidPropDeclaration::Mixin)
-        base.include(::React::Component::Elements)
-        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
-end
+module LucidMaterial
+  module Component
+    module Mixin
+      def self.included(base)
+        base.include(::Native::Wrapper)
+        base.extend(::LucidComponent::NativeLucidComponentConstructor)
+        base.extend(::LucidMaterial::Component::NativeComponentConstructor)
+        base.extend(::LucidPropDeclaration::Mixin)
+        base.include(::React::Component::Elements)
+        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
+end

data/lib/isomorfeus_react_material/lucid_material/component/native_component_constructor.rb

@@ -1,36 +1,36 @@
-module LucidMaterial
-  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 + 'Wrapper'
-        # language=JS
-        %x{
-          base.react_component = Opal.global.React.memo(function(props) {
-            let classes = null;
-            let store;
-            if (base.store_updates) { store = Opal.global.React.useContext(Opal.global.LucidApplicationContext); }
-            let theme = Opal.global.MuiStyles.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 = Opal.global.MuiStyles.makeStyles(styles);
-              }
-              classes = base.use_styles();
-            }
-            let new_props = Object.assign({}, props)
-            new_props.classes = classes;
-            new_props.theme = theme;
-            new_props.store = store;
-            return Opal.global.React.createElement(base.lucid_react_component, new_props);
-          }, Opal.React.props_are_equal);
-          base.react_component.displayName = #{component_name};
-        }
-      end
-    end
-  end
-end
+module LucidMaterial
+  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 + 'Wrapper'
+        # language=JS
+        %x{
+          base.react_component = Opal.global.React.memo(function(props) {
+            let classes = null;
+            let store;
+            if (base.store_updates) { store = Opal.global.React.useContext(Opal.global.LucidApplicationContext); }
+            let theme = Opal.global.MuiStyles.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 = Opal.global.MuiStyles.makeStyles(styles);
+              }
+              classes = base.use_styles();
+            }
+            let new_props = Object.assign({}, props)
+            new_props.classes = classes;
+            new_props.theme = theme;
+            new_props.store = store;
+            return Opal.global.React.createElement(base.lucid_react_component, new_props);
+          }, Opal.React.props_are_equal);
+          base.react_component.displayName = #{component_name};
+        }
+      end
+    end
+  end
+end

data/lib/isomorfeus_react_material/lucid_material/func/base.rb

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

data/lib/isomorfeus_react_material/lucid_material/func/mixin.rb

@@ -1,15 +1,15 @@
-module LucidMaterial
-  module Func
-    module Mixin
-      def self.included(base)
-        base.include(::React::Component::Elements)
-        base.include(::React::Component::Features)
-        base.include(::LucidFunc::Initializer)
-        base.include(::React::FunctionComponent::Api)
-        base.extend(::LucidMaterial::Func::NativeComponentConstructor)
-        base.include(::LucidComponent::Api)
-        base.include(::LucidComponent::StylesApi)
-      end
-    end
-  end
-end
+module LucidMaterial
+  module Func
+    module Mixin
+      def self.included(base)
+        base.include(::React::Component::Elements)
+        base.include(::React::Component::Features)
+        base.include(::LucidFunc::Initializer)
+        base.include(::React::FunctionComponent::Api)
+        base.extend(::LucidMaterial::Func::NativeComponentConstructor)
+        base.include(::LucidComponent::Api)
+        base.include(::LucidComponent::StylesApi)
+      end
+    end
+  end
+end

data/lib/isomorfeus_react_material/lucid_material/func/native_component_constructor.rb

@@ -1,83 +1,83 @@
-module LucidMaterial
-  module Func
-    module NativeComponentConstructor
-      def self.extended(base)
-        component_name = base.to_s
-        %x{
-          base.store_updates = true;
-          base.equality_checker = null;
-          base.instance_init = function(initial) {
-            let ruby_state = { instance: #{base.new(`{}`)} };
-            ruby_state.instance.__ruby_instance = ruby_state.instance;
-            ruby_state.instance.data_access = function() { return this.props.store; }
-            ruby_state.instance.data_access.bind(ruby_state.instance);
-            return ruby_state;
-          }
-          base.instance_reducer = function(state, action) { return state; }
-          base.react_component = Opal.global.React.memo(function(props) {
-            const og = Opal.global;
-            const oper = Opal.React;
-            oper.render_buffer.push([]);
-            // console.log("function pushed", oper.render_buffer, oper.render_buffer.toString());
-            // Lucid functionality
-            let classes = null;
-            let store;
-            if (base.store_updates) { store = og.React.useContext(og.LucidApplicationContext); }
-            let theme = og.MuiStyles.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 = og.MuiStyles.makeStyles(styles);
-              }
-              classes = base.use_styles();
-            }
-            // prepare Ruby instance
-            const [__ruby_state, __ruby_dispatch] = og.React.useReducer(base.instance_reducer, null, base.instance_init);
-            const __ruby_instance = __ruby_state.instance;
-            __ruby_instance.props = Object.assign({}, props);
-            __ruby_instance.props.store = store;
-            __ruby_instance.props.theme = theme;
-            __ruby_instance.props.classes = classes;
-            oper.active_components.push(__ruby_instance);
-            oper.active_redux_components.push(__ruby_instance);
-            let block_result = #{`__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("function popping", oper.render_buffer, oper.render_buffer.toString());
-            let result = oper.render_buffer.pop();
-            return (result.length === 1) ? result[0] : result;
-          }, base.equality_checker);
-          base.react_component.displayName = #{component_name};
-        }
-
-        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 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 #{block.call(`prev_ruby_props`, `next_ruby_props`)};
-              }
-            }
-        end
-
-        def render(&block)
-          `base.render_block = #{block}`
-        end
-      end
-    end
-  end
-end
+module LucidMaterial
+  module Func
+    module NativeComponentConstructor
+      def self.extended(base)
+        component_name = base.to_s
+        %x{
+          base.store_updates = true;
+          base.equality_checker = null;
+          base.instance_init = function(initial) {
+            let ruby_state = { instance: #{base.new(`{}`)} };
+            ruby_state.instance.__ruby_instance = ruby_state.instance;
+            ruby_state.instance.data_access = function() { return this.props.store; }
+            ruby_state.instance.data_access.bind(ruby_state.instance);
+            return ruby_state;
+          }
+          base.instance_reducer = function(state, action) { return state; }
+          base.react_component = Opal.global.React.memo(function(props) {
+            const og = Opal.global;
+            const oper = Opal.React;
+            oper.render_buffer.push([]);
+            // console.log("function pushed", oper.render_buffer, oper.render_buffer.toString());
+            // Lucid functionality
+            let classes = null;
+            let store;
+            if (base.store_updates) { store = og.React.useContext(og.LucidApplicationContext); }
+            let theme = og.MuiStyles.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 = og.MuiStyles.makeStyles(styles);
+              }
+              classes = base.use_styles();
+            }
+            // prepare Ruby instance
+            const [__ruby_state, __ruby_dispatch] = og.React.useReducer(base.instance_reducer, null, base.instance_init);
+            const __ruby_instance = __ruby_state.instance;
+            __ruby_instance.props = Object.assign({}, props);
+            __ruby_instance.props.store = store;
+            __ruby_instance.props.theme = theme;
+            __ruby_instance.props.classes = classes;
+            oper.active_components.push(__ruby_instance);
+            oper.active_redux_components.push(__ruby_instance);
+            let block_result = #{`__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("function popping", oper.render_buffer, oper.render_buffer.toString());
+            let result = oper.render_buffer.pop();
+            return (result.length === 1) ? result[0] : result;
+          }, base.equality_checker);
+          base.react_component.displayName = #{component_name};
+        }
+
+        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 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 #{block.call(`prev_ruby_props`, `next_ruby_props`)};
+              }
+            }
+        end
+
+        def render(&block)
+          `base.render_block = #{block}`
+        end
+      end
+    end
+  end
+end

data/lib/isomorfeus_react_paper/lucid_paper/app/base.rb

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