isomorfeus-react 16.8.9 → 16.9.0

data/lib/react/redux_component/component_class_store_defaults.rb

@@ -1,40 +0,0 @@
-module React
-  module ReduxComponent
-    class ComponentClassStoreDefaults
-      def initialize(state, component_name)
-        @state = state
-        @component_name = component_name
-        if @state.isomorfeus_store
-          @state.isomorfeus_store.merge!(component_class_state: { @component_name => {} })
-        else
-          @state.isomorfeus_store = { component_class_state: { @component_name => {} } }
-        end
-      end
-
-      def method_missing(key, *args, &block)
-        if `args.length > 0`
-          # set initial class state
-          key = key.chop if `key.endsWith('=')`
-          @state.isomorfeus_store[:component_class_state][@component_name][key] = args[0]
-          current_state = Isomorfeus.store.get_state
-          if !(current_state[:component_class_state].key?(@component_name) && current_state[:component_class_state][@component_name].key?(key))
-            Isomorfeus.store.dispatch(type: 'COMPONENT_CLASS_STATE', class: @component_name, name: key, value: args[0])
-          end
-        else
-          # get class state
-
-          # check if we have a component local state value
-
-          if @state.isomorfeus_store[:component_class_state][@component_name].key?(key)
-            return @state.isomorfeus_store[:component_class_state][@component_name][key]
-          end
-        end
-        nil
-      end
-
-      def to_h
-        @state.isomorfeus_store[:component_class_state][@component_name]
-      end
-    end
-  end
-end

data/lib/react/redux_component/component_instance_store_defaults.rb

@@ -1,37 +0,0 @@
-module React
-  module ReduxComponent
-    class ComponentInstanceStoreDefaults
-      def initialize(state, component_name)
-        @state = {}
-        @component_name = component_name
-      end
-
-      def method_missing(key, *args, &block)
-        if `args.length > 0`
-          # set initial class state
-          key = key.chop if `key.endsWith('=')`
-          @state[key] = args[0]
-          current_state = Isomorfeus.store.get_state
-          if !(current_state[:component_state].key?(@component_name) &&
-            current_state[:component_state][@component_name].key?(:instance_defaults) &&
-            current_state[:component_state][@component_name][:instance_defaults].key?(key))
-            Isomorfeus.store.dispatch(type: 'COMPONENT_CLASS_STATE', class: @component_name, name: :instance_defaults, value: { key => args[0]})
-          end
-        else
-          # get class state
-
-          # check if we have a component local state value
-
-          if @state.key?(key)
-            return @state[key]
-          end
-        end
-        nil
-      end
-
-      def to_h
-        @state
-      end
-    end
-  end
-end

data/lib/react/redux_component/initializer.rb

@@ -1,14 +0,0 @@
-module React
-  module ReduxComponent
-    module Initializer
-      def initialize(native_component)
-        @native = native_component
-        @app_store = `Opal.React.ReduxComponent.AppStoreProxy.$new(#{self})`
-        @class_store = `Opal.React.ReduxComponent.ClassStoreProxy.$new(#{self})`
-        @props = `Opal.React.Component.Props.$new(#@native)`
-        @state = `Opal.React.Component.State.$new(#@native)`
-        @store = `Opal.React.ReduxComponent.InstanceStoreProxy.$new(#{self})`
-      end
-    end
-  end
-end

data/lib/react/redux_component/instance_store_proxy.rb

@@ -1,50 +0,0 @@
-module React
-  module ReduxComponent
-    class InstanceStoreProxy
-
-      def initialize(component_instance, access_key = 'state')
-        @native_component_instance = component_instance.to_n
-        @component_instance = component_instance
-        @component_object_id = component_instance.object_id.to_s
-        @access_key = access_key
-      end
-
-      def method_missing(key, *args, &block)
-        @native_component_instance.JS.register_used_store_path(['component_state', @component_object_id, key])
-        if `args.length > 0`
-          # set instance state, simply a dispatch
-
-          action = { type: 'COMPONENT_STATE', object_id: @component_object_id, name: (`key.endsWith('=')` ? key.chop : key), value: args[0] }
-          Isomorfeus.store.dispatch(action)
-
-        else
-          # get instance state
-
-          if @native_component_instance.JS[@access_key].JS[:isomorfeus_store].JS[:component_state].JS[@component_object_id] &&
-            @native_component_instance.JS[@access_key].JS[:isomorfeus_store].JS[:component_state].JS[@component_object_id].JS.hasOwnProperty(key)
-            # check if we have a component local state value
-            return @native_component_instance.JS[@access_key].JS[:isomorfeus_store].JS[:component_state].JS[@component_object_id].JS[key]
-          elsif @component_instance.class.default_instance_store_defined && @component_instance.class.store.to_h.key?(key)
-            # check if a default value was given
-            return @component_instance.class.store.to_h[key]
-          end
-
-          # otherwise return nil
-          return nil
-        end
-      end
-
-      def dispatch(action)
-        Isomorfeus.store.dispatch(action)
-      end
-
-      def subscribe(&block)
-        Isomorfeus.store.subscribe(&block)
-      end
-
-      def unsubscribe(unsubscriber)
-        `unsubscriber()`
-      end
-    end
-  end
-end

data/lib/react/redux_component/mixin.rb

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

data/lib/react/redux_component/native_component_constructor.rb

@@ -1,144 +0,0 @@
-module React
-  module ReduxComponent
-    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 = Object.assign({}, base.$state().$to_n(), { isomorfeus_store: Opal.Isomorfeus.store.native.getState() });
-              } else {
-                this.state = { isomorfeus_store: Opal.Isomorfeus.store.native.getState() };
-              };
-              if (typeof this.state.isomorfeus_store.component_class_state[#{component_name}] === "undefined") {
-                this.state.isomorfeus_store.component_class_state[#{component_name}] = {};
-              };
-              this.__ruby_instance = base.$new(this);
-              this.__object_id = this.__ruby_instance.$object_id().$to_s();
-              if (!this.state.isomorfeus_store.component_state) {
-                this.state.isomorfeus_store.component_state = {};
-                if (base.$default_instance_store_defined()) {
-                  this.state.isomorfeus_store.component_state[this.__object_id] = base.$store.$to_n();
-                } else {
-                  this.state.isomorfeus_store.component_state[this.__object_id] = {};
-                }
-              };
-              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();
-                }
-              }
-              this.listener = this.listener.bind(this);
-              this.unsubscriber = Opal.Isomorfeus.store.native.subscribe(this.listener);
-            }
-            static get displayName() {
-              return #{component_name};
-            }
-            render() {
-              Opal.React.render_buffer.push([]);
-              Opal.React.active_components.push(this);
-              Opal.React.active_redux_components.push(this);
-              this.used_store_paths = [];
-              #{`this.__ruby_instance`.instance_exec(&`base.render_block`)};
-              Opal.React.active_redux_components.pop();
-              Opal.React.active_components.pop();
-              return Opal.React.render_buffer.pop();
-            }
-            data_access() {
-              return this.state.isomorfeus_store
-            }
-            listener() {
-              var next_state = Object.assign({}, this.state, { isomorfeus_store: Opal.Isomorfeus.store.native.getState() });
-              if (this.scu_for_used_store_paths(this, this.state.isomorfeus_store, next_state.isomorfeus_store)) {
-                var self = this;
-                /* setTimeout(function() { */  self.setState(next_state); /* }, 0); */
-              }
-            }
-            register_used_store_path(path) {
-              this.used_store_paths.push(path);
-            }
-            componentWillUnmount() {
-              if (typeof this.unsubscriber === "function") { this.unsubscriber(); };
-            }
-            shouldComponentUpdate(next_props, next_state) {
-              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; };
-                }
-              }
-              var used_store_result;
-              for (var property in next_state) {
-                if (property === "isomorfeus_store") {
-                  used_store_result = this.scu_for_used_store_paths(this, this.state.isomorfeus_store, next_state.isomorfeus_store);
-                  if (used_store_result) {
-                    return true;
-                  }
-                } else 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;
-            }
-            scu_for_used_store_paths(self, current_state, next_state) {
-              var unique_used_store_paths = self.used_store_paths.filter(function(elem, pos, paths) {
-                return (paths.indexOf(elem) === pos);
-              });
-              var used_length = unique_used_store_paths.length;
-              var store_path;
-              var current_value;
-              var next_value;
-              var store_path_last;
-              for (var i = 0; i < used_length; i++) {
-                store_path = unique_used_store_paths[i];
-                store_path_last = store_path.length - 1;
-                if (store_path[store_path_last].constructor === Array) {
-                  store_path[store_path_last] = JSON.stringify(store_path[store_path_last]);
-                }
-                current_value = store_path.reduce(function(prev, curr) { return prev && prev[curr]; }, current_state);
-                next_value = store_path.reduce(function(prev, curr) { return prev && prev[curr]; }, next_state);
-                if (current_value !== next_value) { return true; };
-              }
-              return false;
-            }
-          }
-        }
-      end
-    end
-  end
-end

data/lib/react/redux_component/reducers.rb

@@ -1,48 +0,0 @@
-module React
-  module ReduxComponent
-    module Reducers
-      class << self
-        attr_reader :component_reducers_added
-
-        def add_component_reducers_to_store
-          unless component_reducers_added
-            @_component_reducers_added = true
-            component_reducer = Redux.create_reducer do |prev_state, action|
-              case action[:type]
-              when 'COMPONENT_STATE'
-                if action.key?(:set_state)
-                  action[:set_state]
-                else
-                  new_state = {}.merge!(prev_state) # make a copy of state
-                  new_state[action[:object_id]] = {} unless new_state.key?(action[:object_id])
-                  new_state[action[:object_id]].merge!(action[:name] => action[:value])
-                  new_state
-                end
-              else
-                prev_state
-              end
-            end
-
-            component_class_reducer = Redux.create_reducer do |prev_state, action|
-              case action[:type]
-              when 'COMPONENT_CLASS_STATE'
-                if action.key?(:set_state)
-                  action[:set_state]
-                else
-                  new_state = {}.merge!(prev_state) # make a copy of state
-                  new_state[action[:class]] = {} unless new_state.key?(action[:class])
-                  new_state[action[:class]].merge!(action[:name] => action[:value])
-                  new_state
-                end
-              else
-                prev_state
-              end
-            end
-
-            Redux::Store.add_reducers(component_state: component_reducer, component_class_state: component_class_reducer)
-          end
-        end
-      end
-    end
-  end
-end