isomorfeus-react 16.13.11 → 16.13.12

data/lib/isomorfeus_react/lucid_func/native_component_constructor.rb

@@ -1,81 +1,81 @@
-module LucidFunc
-  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.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 = og.ReactJSS.createUseStyles(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
+module LucidFunc
+  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.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 = og.ReactJSS.createUseStyles(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

data/lib/isomorfeus_react/react/function_component/api.rb

@@ -1,105 +1,105 @@
-module React
-  module FunctionComponent
-    module Api
-      def props
-        @native_props
-      end
-
-      def use_callback(deps, &block)
-        `Opal.global.React.useCallback(function() { #{block.call} }, deps)`
-      end
-
-      def use_context(context)
-        `(typeof context.$is_wrapped_context !== 'undefined')` ? context.to_n : context
-        `Opal.global.React.useContext(native_context)`
-      end
-
-      def use_debug_value(value)
-        `Opal.global.React.useDebugValue(value)`
-      end
-
-      def use_effect(*args, &block)
-        `Opal.global.React.useEffect(function() { #{block.call} }, args)`
-      end
-
-      def use_imperative_handle(ref, *deps, &block)
-        native_ref = `(typeof ref.$is_wrapped_ref !== 'undefined')` ? ref.to_n : ref
-        `Opal.global.React.useImperativeHandle(native_ref, function() { #{block.call} }, deps)`
-      end
-
-      def use_layout_effect(&block)
-        `Opal.global.React.useLayoutEffect(function() { #{block.call} })`
-      end
-
-      def use_memo(*deps, &block)
-        `Opal.global.React.useMemo(function() { #{block.call} }, deps)`
-      end
-
-      def use_reducer(inital_state, &block)
-        state = nil
-        dispatcher = nil
-        %x{
-          [state, dispatcher] = Opal.global.React.useReducer(function(state, action) {
-            #{block.call(state, action)}
-          }, initial_state);
-        }
-        [state, proc { |arg| `dispatcher(arg)` }]
-      end
-
-      def use_ref(native_ref)
-        React::Ref.new(`Opal.global.React.useRef(native_ref)`)
-      end
-
-      def use_state(initial_value)
-        initial = nil
-        setter = nil
-        `[initial, setter] = Opal.global.React.useState(initial_value);`
-        [initial, proc { |arg| `setter(arg)` }]
-      end
-
-      def get_react_element(arg, &block)
-        if block_given?
-          # execute block, fetch last element from buffer
-          %x{
-            let last_buffer_length = Opal.React.render_buffer[Opal.React.render_buffer.length - 1].length;
-            let last_buffer_element = Opal.React.render_buffer[Opal.React.render_buffer.length - 1][last_buffer_length - 1];
-            block.$call();
-            // console.log("get_react_element popping", Opal.React.render_buffer, Opal.React.render_buffer.toString())
-            let new_element = Opal.React.render_buffer[Opal.React.render_buffer.length - 1].pop();
-            if (last_buffer_element === new_element) { #{Isomorfeus.raise_error(message: "Block did not create any React element!")} }
-            return new_element;
-          }
-        else
-          # element was rendered before being passed as arg
-          # fetch last element from buffer
-          # `console.log("get_react_element popping", Opal.React.render_buffer, Opal.React.render_buffer.toString())`
-          `Opal.React.render_buffer[Opal.React.render_buffer.length - 1].pop()`
-        end
-      end
-      alias gre get_react_element
-
-      def render_react_element(el)
-        # push el to buffer
-        `Opal.React.render_buffer[Opal.React.render_buffer.length - 1].push(el)`
-        # `console.log("render_react_element pushed", Opal.React.render_buffer, Opal.React.render_buffer.toString())`
-        nil
-      end
-      alias rre render_react_element
-
-      def method_ref(method_symbol, *args)
-        method_key = "#{method_symbol}#{args}"
-        %x{
-          if (#{self}.method_refs && #{self}.method_refs[#{method_key}]) { return #{self}.method_refs[#{method_key}]; }
-          if (!#{self}.method_refs) { #{self}.method_refs = {}; }
-          #{self}.method_refs[#{method_key}] = { m: #{method(method_symbol)}, a: args };
-          return #{self}.method_refs[#{method_key}];
-        }
-      end
-      alias m_ref method_ref
-
-      def to_n
-        self
-      end
-    end
-  end
-end
+module React
+  module FunctionComponent
+    module Api
+      def props
+        @native_props
+      end
+
+      def use_callback(deps, &block)
+        `Opal.global.React.useCallback(function() { #{block.call} }, deps)`
+      end
+
+      def use_context(context)
+        `(typeof context.$is_wrapped_context !== 'undefined')` ? context.to_n : context
+        `Opal.global.React.useContext(native_context)`
+      end
+
+      def use_debug_value(value)
+        `Opal.global.React.useDebugValue(value)`
+      end
+
+      def use_effect(*args, &block)
+        `Opal.global.React.useEffect(function() { #{block.call} }, args)`
+      end
+
+      def use_imperative_handle(ref, *deps, &block)
+        native_ref = `(typeof ref.$is_wrapped_ref !== 'undefined')` ? ref.to_n : ref
+        `Opal.global.React.useImperativeHandle(native_ref, function() { #{block.call} }, deps)`
+      end
+
+      def use_layout_effect(&block)
+        `Opal.global.React.useLayoutEffect(function() { #{block.call} })`
+      end
+
+      def use_memo(*deps, &block)
+        `Opal.global.React.useMemo(function() { #{block.call} }, deps)`
+      end
+
+      def use_reducer(inital_state, &block)
+        state = nil
+        dispatcher = nil
+        %x{
+          [state, dispatcher] = Opal.global.React.useReducer(function(state, action) {
+            #{block.call(state, action)}
+          }, initial_state);
+        }
+        [state, proc { |arg| `dispatcher(arg)` }]
+      end
+
+      def use_ref(native_ref)
+        React::Ref.new(`Opal.global.React.useRef(native_ref)`)
+      end
+
+      def use_state(initial_value)
+        initial = nil
+        setter = nil
+        `[initial, setter] = Opal.global.React.useState(initial_value);`
+        [initial, proc { |arg| `setter(arg)` }]
+      end
+
+      def get_react_element(arg, &block)
+        if block_given?
+          # execute block, fetch last element from buffer
+          %x{
+            let last_buffer_length = Opal.React.render_buffer[Opal.React.render_buffer.length - 1].length;
+            let last_buffer_element = Opal.React.render_buffer[Opal.React.render_buffer.length - 1][last_buffer_length - 1];
+            block.$call();
+            // console.log("get_react_element popping", Opal.React.render_buffer, Opal.React.render_buffer.toString())
+            let new_element = Opal.React.render_buffer[Opal.React.render_buffer.length - 1].pop();
+            if (last_buffer_element === new_element) { #{Isomorfeus.raise_error(message: "Block did not create any React element!")} }
+            return new_element;
+          }
+        else
+          # element was rendered before being passed as arg
+          # fetch last element from buffer
+          # `console.log("get_react_element popping", Opal.React.render_buffer, Opal.React.render_buffer.toString())`
+          `Opal.React.render_buffer[Opal.React.render_buffer.length - 1].pop()`
+        end
+      end
+      alias gre get_react_element
+
+      def render_react_element(el)
+        # push el to buffer
+        `Opal.React.render_buffer[Opal.React.render_buffer.length - 1].push(el)`
+        # `console.log("render_react_element pushed", Opal.React.render_buffer, Opal.React.render_buffer.toString())`
+        nil
+      end
+      alias rre render_react_element
+
+      def method_ref(method_symbol, *args)
+        method_key = "#{method_symbol}#{args}"
+        %x{
+          if (#{self}.method_refs && #{self}.method_refs[#{method_key}]) { return #{self}.method_refs[#{method_key}]; }
+          if (!#{self}.method_refs) { #{self}.method_refs = {}; }
+          #{self}.method_refs[#{method_key}] = { m: #{method(method_symbol)}, a: args };
+          return #{self}.method_refs[#{method_key}];
+        }
+      end
+      alias m_ref method_ref
+
+      def to_n
+        self
+      end
+    end
+  end
+end

data/lib/isomorfeus_react/react/function_component/base.rb

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

data/lib/isomorfeus_react/react/function_component/initializer.rb

@@ -1,10 +1,10 @@
-module React
-  module FunctionComponent
-    module Initializer
-      def initialize
-        self.JS[:native_props] = `{ props: null }`
-        @native_props = ::React::Component::Props.new(self)
-      end
-    end
-  end
-end
+module React
+  module FunctionComponent
+    module Initializer
+      def initialize
+        self.JS[:native_props] = `{ props: null }`
+        @native_props = ::React::Component::Props.new(self)
+      end
+    end
+  end
+end

data/lib/isomorfeus_react/react/function_component/mixin.rb

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

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

@@ -1,48 +1,48 @@
-module React
-  module FunctionComponent
-    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.react_component = function(props) {
-            const oper = Opal.React;
-            oper.render_buffer.push([]);
-            // console.log("function 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("function popping", oper.render_buffer, oper.render_buffer.toString());
-            let result = oper.render_buffer.pop();
-            return (result.length === 1) ? result[0] : result;
-          }
-          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 FunctionComponent
+    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.react_component = function(props) {
+            const oper = Opal.React;
+            oper.render_buffer.push([]);
+            // console.log("function 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("function popping", oper.render_buffer, oper.render_buffer.toString());
+            let result = oper.render_buffer.pop();
+            return (result.length === 1) ? result[0] : result;
+          }
+          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/react/memo_component/base.rb

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

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

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