isomorfeus-react 16.9.24 → 16.10.0

data/lib/react/component/mixin.rb

@@ -1,19 +0,0 @@
-module React
-  module Component
-    module Mixin
-      def self.included(base)
-        base.include(::Native::Wrapper)
-        base.extend(::React::Component::NativeComponentConstructor)
-        base.extend(::LucidPropDeclaration::Mixin)
-        base.extend(::React::Component::ShouldComponentUpdate)
-        base.extend(::React::Component::EventHandler)
-        base.include(::React::Component::Elements)
-        base.include(::React::Component::API)
-        base.include(::React::Component::Callbacks)
-        base.include(::React::Component::Initializer)
-        base.include(::React::Component::Features)
-        base.include(::React::Component::Resolution)
-      end
-    end
-  end
-end

data/lib/react/component/native_component_constructor.rb

@@ -1,93 +0,0 @@
-module React
-  module Component
-    module NativeComponentConstructor
-      # for should_component_update we apply ruby semantics for comparing props
-      # to do so, we convert the props to ruby hashes and then compare
-      # this makes sure, that for example rubys Nil object gets handled properly
-      def self.extended(base)
-        component_name = base.to_s
-        # language=JS
-        %x{
-          base.react_component = class extends Opal.global.React.Component {
-            constructor(props) {
-              super(props);
-              if (base.$default_state_defined()) {
-                this.state = base.$state().$to_n();
-              } else {
-                this.state = {};
-              };
-              this.__ruby_instance = base.$new(this);
-              var event_handlers = #{base.event_handlers};
-              for (var i = 0; i < event_handlers.length; i++) {
-                this[event_handlers[i]] = this[event_handlers[i]].bind(this);
-              }
-              var defined_refs = #{base.defined_refs};
-              for (var ref in defined_refs) {
-                if (defined_refs[ref] != null) {
-                  this[ref] = function(element) {
-                    element = Opal.React.native_element_or_component_to_ruby(element);
-                    #{`this.__ruby_instance`.instance_exec(`element`, &`defined_refs[ref]`)}
-                  }
-                  this[ref] = this[ref].bind(this);
-                } else {
-                  this[ref] = Opal.global.React.createRef();
-                }
-              }
-            }
-            static get displayName() {
-              return #{component_name};
-            }
-            render() {
-              Opal.React.render_buffer.push([]);
-              Opal.React.active_components.push(this);
-              #{`this.__ruby_instance`.instance_exec(&`base.render_block`)};
-              Opal.React.active_components.pop();
-              return Opal.React.render_buffer.pop();
-            }
-            shouldComponentUpdate(next_props, next_state) {
-              if (base.has_custom_should_component_update) {
-                return this.__ruby_instance["$should_component_update"](#{(Hash.new(next_props))}, #{Hash.new(next_state)});
-              } else {
-                var next_props_keys = Object.keys(next_props);
-                var this_props_keys = Object.keys(this.props);
-                if (next_props_keys.length !== this_props_keys.length) { return true; }
-
-                var next_state_keys = Object.keys(next_state);
-                var this_state_keys = Object.keys(this.state);
-                if (next_state_keys.length !== this_state_keys.length) { return true; }
-
-                for (var property in next_props) {
-                  if (next_props.hasOwnProperty(property)) {
-                    if (!this.props.hasOwnProperty(property)) { return true; };
-                    if (property == "children") { if (next_props.children !== this.props.children) { return true; }}
-                    else if (typeof next_props[property] !== "undefined" && next_props[property] !== null &&
-                             typeof next_props[property]['$!='] !== "undefined" &&
-                             typeof this.props[property] !== "undefined" && this.props[property] !== null &&
-                             typeof this.props[property]['$!='] !== "undefined") {
-                      if (#{ !! (`next_props[property]` != `this.props[property]`) }) { return true; };
-                    } else if (next_props[property] !== this.props[property]) { return true; };
-                  }
-                }
-                for (var property in next_state) {
-                  if (next_state.hasOwnProperty(property)) {
-                    if (!this.state.hasOwnProperty(property)) { return true; };
-                    if (next_state[property] !== null && typeof next_state[property]['$!='] !== "undefined" &&
-                        this.state[property] !== null && typeof this.state[property]['$!='] !== "undefined") {
-                      if (#{ !! (`next_state[property]` != `this.state[property]`) }) { return true };
-                    } else if (next_state[property] !== this.state[property]) { return true };
-                  }
-                }
-                return false;
-              }
-            }
-            validateProp(props, propName, componentName) {
-              try { base.$validate_prop(propName, props[propName]) }
-              catch (e) { return new Error(componentName + " Error: prop validation failed: " + e.message); }
-              return null;
-            }
-          }
-        }
-      end
-    end
-  end
-end

data/lib/react/component/props.rb

@@ -1,59 +0,0 @@
-module React
-  module Component
-    class Props
-      include ::Native::Wrapper
-
-      def method_missing(prop, *args, &block)
-        %x{
-          var prop_name = Opal.React.lower_camelize(prop);
-          if (typeof #@native.props[prop_name] === 'undefined') { return #{nil}; }
-          return #@native.props[prop_name];
-        }
-      end
-
-      def classes
-        @classes ||= `Opal.React.Component.Styles.$new(#@native.props.classes)`
-      end
-
-      def theme
-        @theme ||= `Opal.React.Component.Styles.$new(#@native.props.theme)`
-      end
-
-      def isomorfeus_store
-        @native.JS[:props].JS[:isomorfeus_store]
-      end
-
-      # for router convenience
-      def history
-        return nil unless @native.JS[:props].JS[:history]
-        if @native.JS[:props].JS[:history].JS[:pathname]
-          React::Component::History.new(@native.JS[:props].JS[:history])
-        else
-          @native.JS[:props].JS[:history]
-        end
-      end
-
-      def location
-        return nil unless @native.JS[:props].JS[:location]
-        if @native.JS[:props].JS[:location].JS[:pathname]
-          React::Component::Location.new(@native.JS[:props].JS[:location])
-        else
-          @native.JS[:props].JS[:location]
-        end
-      end
-
-      def match
-        return nil unless @native.JS[:props].JS[:match]
-        if @native.JS[:props].JS[:match].JS[:path]
-          React::Component::Match.new(@native.JS[:props].JS[:match])
-        else
-          @native.JS[:props].JS[:match]
-        end
-      end
-
-      def to_n
-        @native.JS[:props]
-      end
-    end
-  end
-end

data/lib/react/component/resolution.rb

@@ -1,70 +0,0 @@
-module React
-  module Component
-    module Resolution
-      def self.included(base)
-        base.instance_exec do
-          alias _react_component_resolution_original_const_missing const_missing
-
-          def const_missing(const_name)
-            # language=JS
-            %x{
-              if (typeof Opal.global[const_name] === "object") {
-                var new_const = #{React::NativeConstantWrapper.new(`Opal.global[const_name]`, const_name)};
-                #{Object.const_set(const_name, `new_const`)};
-                return new_const;
-              } else {
-                return #{_react_component_resolution_original_const_missing(const_name)};
-              }
-            }
-          end
-        end
-      end
-
-
-      alias _react_component_resolution_original_method_missing method_missing
-
-      def method_missing(component_name, *args, &block)
-        # html tags are defined as methods, so they will not end up here.
-        # first check for native component and render it, we want to be fast for native components
-        # second check for ruby component and render it, they are a bit slower anyway
-        # third pass on method missing
-        # language=JS
-        %x{
-          var component = null;
-          var component_type = typeof Opal.global[component_name];
-          if (component_type === "function" || component_type === "object") {
-            component = Opal.global[component_name];
-          } else {
-            var modules = self.$class().$to_s().split("::");
-            var modules_length = modules.length - 1;
-            var module;
-            var constant;
-            for (var i = modules_length; i > 0; i--) {
-              try {
-                module = modules.slice(0, i).join('::')
-                constant = self.$class().$const_get(module).$const_get(component_name, false);
-                if (typeof constant.react_component !== 'undefined') {
-                  component = constant.react_component;
-                  break;
-                }
-              } catch(err) { component = null; }
-            }
-            if (!component) {
-              try {
-                constant = Opal.Object.$const_get(component_name);
-                if (typeof constant.react_component !== 'undefined') {
-                  component = constant.react_component;
-                }
-              } catch(err) { component = null; }
-            }
-          }
-          if (component) {
-            return Opal.React.internal_prepare_args_and_render(component, args, block);
-          } else {
-            return #{_react_component_resolution_original_method_missing(component_name, *args, block)};
-          }
-        }
-      end
-    end
-  end
-end

data/lib/react/component/should_component_update.rb

@@ -1,14 +0,0 @@
-module React
-  module Component
-    module ShouldComponentUpdate
-      def self.extended(base)
-        base.define_singleton_method(:should_component_update?) do |&block|
-          `base.has_custom_should_component_update = true`
-          define_method(:should_component_update) do |next_props, next_state|
-            !!block.call(Hash.new(next_props), Hash.new(next_state))
-          end
-        end
-      end
-    end
-  end
-end

data/lib/react/component/state.rb

@@ -1,52 +0,0 @@
-module React
-  module Component
-    class State
-      include ::Native::Wrapper
-
-      def method_missing(key, *args, &block)
-        if `args.length > 0`
-          new_state = `{}`
-          new_state.JS[(`key.endsWith('=')` ? key.chop : key)] = args[0]
-          if block_given?
-            @native.JS.setState(new_state, `function() { block.$call(); }`)
-          else
-            @native.JS.setState(new_state, `null`)
-          end
-        else
-          return nil if `typeof #@native.state[key] == "undefined"`
-          @native.JS[:state].JS[key]
-        end
-      end
-
-      def set_state(updater, &block)
-        new_state = `{}`
-        updater.keys.each do |key|
-          new_state.JS[key] = updater[key]
-        end
-        if block_given?
-          @native.JS.setState(new_state, `function() { block.$call(); }`)
-        else
-          @native.JS.setState(new_state, `null`)
-        end
-      end
-
-      def size
-        `Object.keys(#@native.state).length`;
-      end
-
-      def to_n
-        %x{
-          var new_native = {};
-          for (var key in #@native.state) {
-            if (typeof #@native.state[key].$to_n !== "undefined") {
-              new_native[key] = #@native.state[key].$to_n();
-            } else {
-              new_native[key] = #@native.state[key];
-            }
-          }
-          return new_native;
-        }
-      end
-    end
-  end
-end

data/lib/react/component/styles.rb

@@ -1,27 +0,0 @@
-module React
-  module Component
-    class Styles
-      def initialize(native)
-        @native = native
-      end
-
-      def method_missing(prop, *args, &block)
-        %x{
-          if (!#@native || typeof #@native[prop] === 'undefined') { return #{nil}; }
-          let value = #@native[prop];
-          if (typeof value === 'string' || typeof value === 'number' || Array.isArray(value)) { return value; }
-          if (typeof value === 'function') { return #{Proc.new { `value()` }} }
-          return Opal.React.Component.Styles.$new(value);
-        }
-      end
-
-      def to_h
-        `Opal.Hash.$new(#@native)`
-      end
-
-      def to_n
-        @native
-      end
-    end
-  end
-end

data/lib/react/component/unsafe_api.rb

@@ -1,33 +0,0 @@
-module React
-  module Component
-    module UnsafeAPI
-      def self.included(base)
-        base.instance_exec do
-          def unsafe_component_will_mount(&block)
-            %x{
-              self.react_component.prototype.UNSAFE_componentWillMount = function() {
-                return #{`this.__ruby_instance`.instance_exec(&block)};
-              }
-            }
-          end
-
-          def unsafe_component_will_receive_props(&block)
-            %x{
-              self.react_component.prototype.UNSAFE_componentWillReceiveProps = function(next_props) {
-                return #{`this.__ruby_instance`.instance_exec(React::Component::Props.new(`{props: next_props}`), &block)};
-              }
-            }
-          end
-
-          def unsafe_component_will_update(&block)
-            %x{
-              self.react_component.prototype.UNSAFE_componentWillUpdate = function(next_props, next_state) {
-                return #{`this.__ruby_instance`.instance_exec(React::Component::Props.new(`{props: next_props}`), `Opal.Hash.$new(next_state)`, &block)};
-              }
-            }
-          end
-        end
-      end
-    end
-  end
-end

data/lib/react/context_wrapper.rb

@@ -1,46 +0,0 @@
-module React
-  class ContextWrapper
-    include ::Native::Wrapper
-
-    def is_wrapped_context
-      true
-    end
-
-    def Consumer(*args, &block)
-      %x{
-        let children = null;
-        let props = null;
-
-        if (args.length > 0) { props = Opal.React.to_native_react_props(args[0]); }
-
-        let react_element = Opal.global.React.createElement(this.native.Consumer, props, function(value) {
-          if (block !== nil) {
-            Opal.React.render_buffer.push([]);
-            let block_result = block.$call();
-            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];
-            if (block_result && block_result !== last_buffer_element && (block_result !== nil && (typeof block_result === "string" || typeof block_result.$$typeof === "symbol" ||
-              (typeof block_result.constructor !== "undefined" && block_result.constructor === Array && block_result[0] && typeof block_result[0].$$typeof === "symbol")
-              ))) {
-              Opal.React.render_buffer[Opal.React.render_buffer.length - 1].push(block_result);
-            }
-            children = Opal.React.render_buffer.pop();
-            if (children.length == 1) { children = children[0]; }
-            else if (children.length == 0) { children = null; }
-          }
-          return Opal.React.render_buffer.pop();
-        });
-        Opal.React.render_buffer[Opal.React.render_buffer.length - 1].push(react_element);
-        return null;
-      }
-    end
-
-    def Provider(*args, &block)
-      %x{
-        var props = null;
-        if (args.length > 0) { props = Opal.React.to_native_react_props(args[0]); }
-        Opal.React.internal_render(this.native.Provider, props, null, block);
-      }
-    end
-  end
-end

data/lib/react/function_component/api.rb

@@ -1,63 +0,0 @@
-module React
-  module FunctionComponent
-    module API
-      attr_accessor :props
-
-      def initialize(props)
-        @props = ::React::Component::Props.new(`{props: 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(&block)
-        `Opal.global.React.useEffect(function() { #{block.call} })`
-      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(initial_value)
-        React::Ref.new(`Opal.global.React.useRef(initial_value)`)
-      end
-
-      def use_state(initial_value)
-        initial = nil
-        setter = nil
-        `[initial, setter] = Opal.global.React.useState(initial_value);`
-        [initial, proc { |arg| `setter(arg)` }]
-      end
-    end
-  end
-end