isomorfeus-redux 4.1.13 → 4.1.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8d912db358118c0d9f353c8acf7f3b529c982e9d1f798d8e0331da47879cc970
-  data.tar.gz: 9683d346b2f91ac9ce03d9c9e1e965e018f454fce79fd072cc4f3e58afb7a62f
+  metadata.gz: 220dc51a83d5f18cace172fb7bc59be39088fd6c737f7f7e8654aa12badac83a
+  data.tar.gz: bca4b194909499cd142e5ea25f3b839cb93897da0951c9295543bd36c1661ffe
 SHA512:
-  metadata.gz: b67e553f57b28e9363e5627ed4cdb27b2f4ff540cd918363ace1a19a27de960403e98cef0fa652ea34c9447efe61a0396bdb317f6eabfd949e88a7cc5c48d65a
-  data.tar.gz: 6129c5401a995ec02c5eabee7be2b4fdd0a8188bdcdaa79fa93fcbc7879dae42f6b018ad6cde58c97e27469b886c58a27df9188950a9e70d30ee6e67010bf6d6
+  metadata.gz: 0ca0f077dbca3a6885a2891310a51ac4af9a57cab926551dac0a559ba45e504100da1cd016f4164bbd5f2cf7c69c3a4c190e51ae775a52b60196fa83dac8c06e
+  data.tar.gz: 01f0009e2b8a6496c88c89b19267faeabbf2faa068118ba8d29ae1cae046299321131e6c418664aa2177e53dc9665ff8818251185f3b0c80f6774eefc01ffa9d

data/lib/redux/reducers.rb

@@ -1,77 +1,54 @@
-module Redux
-  module Reducers
-    def self.add_application_reducers_to_store
-      unless @_application_reducers_added
-        @_application_reducers_added = true
-        app_reducer = Redux.create_reducer do |prev_state, action|
-          case action[:type]
-          when 'APPLICATION_STATE'
-            if action.key?(:set_state)
-              action[:set_state]
-            else
-              new_state = {}.merge!(prev_state) # make a copy of state
-              if action.key?(:collected)
-                action[:collected].each do |act|
-                  new_state.merge!(act[:name] => act[:value])
-                end
-              else
-                new_state.merge!(action[:name] => action[:value])
-              end
-              new_state
-            end
-          else
-            prev_state
-          end
-        end
-
-        instance_reducer = Redux.create_reducer do |prev_state, action|
-          case action[:type]
-          when 'INSTANCE_STATE'
-            if action.key?(:set_state)
-              action[:set_state]
-            else
-              new_state = {}.merge!(prev_state) # make a copy of state
-              if action.key?(:collected)
-                action[:collected].each do |act|
-                  new_state[act[:object_id]] = {} unless new_state.key?(act[:object_id])
-                  new_state[act[:object_id]].merge!(act[:name] => act[:value])
-                end
-              else
-                new_state[action[:object_id]] = {} unless new_state.key?(action[:object_id])
-                new_state[action[:object_id]].merge!(action[:name] => action[:value])
-              end
-              new_state
-            end
-          else
-            prev_state
-          end
-        end
-
-        class_reducer = Redux.create_reducer do |prev_state, action|
-          case action[:type]
-          when 'CLASS_STATE'
-            if action.key?(:set_state)
-              action[:set_state]
-            else
-              new_state = {}.merge!(prev_state) # make a copy of state
-              if action.key?(:collected)
-                action[:collected].each do |act|
-                  new_state[act[:class]] = {} unless new_state.key?(act[:class])
-                  new_state[act[:class]].merge!(act[:name] => act[:value])
-                end
-              else
-                new_state[action[:class]] = {} unless new_state.key?(action[:class])
-                new_state[action[:class]].merge!(action[:name] => action[:value])
-              end
-              new_state
-            end
-          else
-            prev_state
-          end
-        end
-        Redux::Store.preloaded_state_merge!(application_state: {}, instance_state: {}, class_state: {})
-        Redux::Store.add_reducers(application_state: app_reducer, instance_state: instance_reducer, class_state: class_reducer)
-      end
-    end
-  end
-end
+module Redux
+  module Reducers
+    def self.add_application_reducers_to_store
+      unless @_application_reducers_added
+        @_application_reducers_added = true
+        app_reducer = Redux.create_reducer do |prev_state, action|
+          case action[:type]
+          when 'APPLICATION_STATE'
+            if action.key?(:set_state)
+              action[:set_state]
+            else
+              new_state = {}.merge!(prev_state) # make a copy of state
+              if action.key?(:collected)
+                action[:collected].each do |act|
+                  new_state.merge!(act[:name] => act[:value])
+                end
+              else
+                new_state.merge!(action[:name] => action[:value])
+              end
+              new_state
+            end
+          else
+            prev_state.nil? ? {} : prev_state
+          end
+        end
+
+        class_reducer = Redux.create_reducer do |prev_state, action|
+          case action[:type]
+          when 'CLASS_STATE'
+            if action.key?(:set_state)
+              action[:set_state]
+            else
+              new_state = {}.merge!(prev_state) # make a copy of state
+              if action.key?(:collected)
+                action[:collected].each do |act|
+                  new_state[act[:class]] = {} unless new_state.key?(act[:class])
+                  new_state[act[:class]].merge!(act[:name] => act[:value])
+                end
+              else
+                new_state[action[:class]] = {} unless new_state.key?(action[:class])
+                new_state[action[:class]].merge!(action[:name] => action[:value])
+              end
+              new_state
+            end
+          else
+            prev_state.nil? ? {} : prev_state
+          end
+        end
+        Redux::Store.preloaded_state_merge!(application_state: {}, class_state: {})
+        Redux::Store.add_reducers(application_state: app_reducer, class_state: class_reducer)
+      end
+    end
+  end
+end

data/lib/redux/store.rb

@@ -1,183 +1,199 @@
-module Redux
-  class Store
-    include Native::Wrapper
-
-    def self.add_middleware(middleware)
-      if Isomorfeus.store
-        `console.warning("Adding middleware after Store initialization may have side effects! Saving state and initializing new store with restored state!")`
-        middlewares << middleware
-        preloaded_state = Isomorfeus.store.get_state
-        init!
-      else
-        middlewares << middleware
-      end
-    end
-
-    def self.add_reducer(reducer)
-      if Isomorfeus.store
-        # if the store has been initalized already, add the reducer to the instance
-        Isomorfeus.store.add_reducer(reducer)
-      else
-        # otherwise just add it to the reducers, so that they will be used when initializing the store
-        preloaded_state[reducer.keys.first] = {} unless preloaded_state.key?(reducer.keys.first)
-        reducers.merge!(reducer)
-      end
-    end
-
-    def self.add_reducers(new_reducers)
-      if Isomorfeus.store
-        # if the store has been initalized already, add the reducer to the instance
-        Isomorfeus.store.add_reducers(new_reducers)
-      else
-        # otherwise just add it to the reducers, so that they will be used when initializing the store
-        new_reducers.each do |key, value|
-          add_reducer(key => value)
-        end
-      end
-    end
-
-    # called from Isomorfeus.init
-    def self.init!
-      next_reducer = Redux.combine_reducers(@reducers)
-      if middlewares.any?
-        enhancer = Redux.apply_middleware(middlewares)
-        Redux::Store.new(next_reducer, preloaded_state, enhancer)
-      else
-        Redux::Store.new(next_reducer, preloaded_state)
-      end
-    end
-
-    def self.middlewares
-      @middlewares ||= []
-    end
-
-    def self.preloaded_state_merge!(ruby_hash)
-      preloaded_state.merge!(ruby_hash)
-    end
-
-    def self.preloaded_state
-      @preloaded_state ||= {}
-    end
-
-    def self.preloaded_state=(ruby_hash)
-      @preloaded_state = ruby_hash
-    end
-
-    def self.reducers
-      @reducers ||= {}
-    end
-
-    def initialize(reducer, preloaded_state = `null`, enhancer = `null`)
-      @deferred_actions = {}
-      @deferred_dispatcher = nil
-      @last_dispatch_time = Time.now
-      %x{
-        var compose = (typeof window === 'object' && window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__) || Opal.global.Redux.compose;
-        var devext_enhance;
-        if (typeof window === 'object' && window.__REDUX_DEVTOOLS_EXTENSION__) { devext_enhance = window.__REDUX_DEVTOOLS_EXTENSION__(); }
-        var real_preloaded_state;
-        if (typeof preloaded_state.$class === "function" && preloaded_state.$class() == "Hash") {
-          if (preloaded_state.$size() == 0) {
-            real_preloaded_state = null;
-          } else {
-            real_preloaded_state = preloaded_state.$to_n();
-          }
-        } else if (preloaded_state == nil) {
-          real_preloaded_state = null;
-        } else {
-          real_preloaded_state = preloaded_state;
-        }
-        if (enhancer && real_preloaded_state) {
-          this.native = Opal.global.Redux.createStore(reducer, real_preloaded_state, compose(enhancer));
-        } else if (real_preloaded_state) {
-          this.native = Opal.global.Redux.createStore(reducer, real_preloaded_state, devext_enhance);
-        } else if (enhancer) {
-          this.native = Opal.global.Redux.createStore(reducer, compose(enhancer));
-        } else {
-          this.native = Opal.global.Redux.createStore(reducer, devext_enhance);
-        }
-      }
-    end
-
-    def add_reducer(reducer)
-      self.class.reducers.merge!(reducer)
-      next_reducer = Redux.combine_reducers(self.class.reducers)
-      replace_reducer(next_reducer)
-    end
-
-    def add_reducers(new_reducers)
-      self.class.reducers.merge!(new_reducers)
-      next_reducer = Redux.combine_reducers(self.class.reducers)
-      replace_reducer(next_reducer)
-    end
-
-    def dispatch(action)
-      %x{
-        if (typeof action.$class === "function" && action.$class() == "Hash") {
-          this.native.dispatch(action.$to_n());
-        } else {
-          this.native.dispatch(action);
-        }
-      }
-    end
-
-    def get_state
-      Hash.new(`this.native.getState()`)
-    end
-
-    def collect_and_defer_dispatch(action)
-      if !Isomorfeus.on_ssr?
-        type = action.delete(:type)
-        @deferred_actions[type] = [] unless @deferred_actions.key?(type)
-        @deferred_actions[type].push(action)
-        @last_dispatch_time = `Date.now()`
-        # `console.log(#@last_dispatch_time)`
-        deferred_dispatcher(`Date.now()`) unless @deferred_dispatcher
-      else
-        dispatch(action)
-      end
-      nil
-    end
-
-    def replace_reducer(next_reducer)
-      `this.native.replaceReducer(next_reducer)`
-    end
-
-    # returns function needed to unsubscribe the listener
-    def subscribe(&listener)
-      `this.native.subscribe(function() { return listener.$call(); })`
-    end
-
-    private
-
-    def deferred_dispatcher(first)
-      @deferred_dispatcher = true
-      %x{
-        setTimeout(function() {
-          if (#{wait_longer?(first)}) { #{deferred_dispatcher(first)} }
-          else { #{dispatch_deferred_dispatches} }
-        }, 10)
-      }
-    end
-
-    def dispatch_deferred_dispatches
-      # `console.log(Date.now())`
-      @deferred_dispatcher = false
-      actions = @deferred_actions
-      @deferred_actions = {}
-      actions.each do |type, data|
-        dispatch(type: type, collected: data)
-      end
-    end
-
-    def wait_longer?(first)
-      t = `Date.now()`
-      time_since_first = `t - first`
-      # `console.log('delta', time_since_first)`
-      return true if `typeof Opal.Preact !== 'undefined' && typeof Opal.Preact.render_buffer !== 'undefined' && Opal.Preact.render_buffer.length > 0 && time_since_first < 1000`
-      return false if time_since_first > 100 # ms
-      return false if (`t - #@last_dispatch_time`) > 9 # ms
-      return true
-    end
-  end
-end
+module Redux
+  class Store
+    include Native::Wrapper
+
+    class << self
+      def add_middleware(middleware)
+        if Isomorfeus.store
+          `console.warning("Adding middleware after Store initialization may have side effects! Saving state and initializing new store with restored state!")`
+          middlewares << middleware
+          preloaded_state = Isomorfeus.store.get_state
+          init!
+        else
+          middlewares << middleware
+        end
+      end
+
+      def add_reducer(reducer)
+        if Isomorfeus.store
+          # if the store has been initalized already, add the reducer to the instance
+          Isomorfeus.store.add_reducer(reducer)
+        else
+          # otherwise just add it to the reducers, so that they will be used when initializing the store
+          preloaded_state[reducer.keys.first] = {} unless preloaded_state.key?(reducer.keys.first)
+          reducers.merge!(reducer)
+        end
+      end
+
+      def add_reducers(new_reducers)
+        if Isomorfeus.store
+          # if the store has been initalized already, add the reducer to the instance
+          Isomorfeus.store.add_reducers(new_reducers)
+        else
+          # otherwise just add it to the reducers, so that they will be used when initializing the store
+          new_reducers.each do |key, value|
+            add_reducer(key => value)
+          end
+        end
+      end
+
+      # called from Isomorfeus.init
+      def init!
+        next_reducer = Redux.combine_reducers(@reducers)
+        if middlewares.any?
+          enhancer = Redux.apply_middleware(middlewares)
+          Redux::Store.new(next_reducer, preloaded_state, enhancer)
+        else
+          Redux::Store.new(next_reducer, preloaded_state)
+        end
+      end
+
+      def middlewares
+        @middlewares ||= []
+      end
+
+      def preloaded_state_merge!(ruby_hash)
+        preloaded_state.merge!(ruby_hash)
+      end
+
+      def preloaded_state
+        @preloaded_state ||= {}
+      end
+
+      def preloaded_state=(ruby_hash)
+        @preloaded_state = ruby_hash
+      end
+
+      def reducers
+        @reducers ||= {}
+      end
+    end
+
+    def initialize(reducer, preloaded_state = nil, enhancer = nil)
+      @deferred_actions = {}
+      @deferred_dispatcher = nil
+      @last_dispatch_time = Time.now
+      %x{
+        var ogre = Opal.global.Redux;
+        var compose = (typeof window === 'object' && window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__) || ogre.compose;
+        if (enhancer == nil) { enhancer = null; }
+        if (typeof window === 'object' && window.__REDUX_DEVTOOLS_EXTENSION__) {
+          var devext_enhance = window.__REDUX_DEVTOOLS_EXTENSION__();
+          if (enhancer) { enhancer = compose([enhancer, devext_enhance]); }
+          else { enhancer = devext_enhance; }
+        }
+        if (preloaded_state == nil) {
+          preloaded_state = null;
+        } else if (typeof preloaded_state.$class === "function" && preloaded_state.$class() == "Hash") {
+          if (preloaded_state.$size() == 0) {
+            preloaded_state = null;
+          } else {
+            preloaded_state = preloaded_state.$to_n();
+          }
+        }
+        if (enhancer && preloaded_state) {
+          this.native = ogre.createStore(reducer, preloaded_state, enhancer);
+        } else if (preloaded_state) {
+          this.native = ogre.createStore(reducer, preloaded_state);
+        } else if (enhancer) {
+          this.native = ogre.createStore(reducer, enhancer);
+        } else {
+          this.native = ogre.createStore(reducer);
+        }
+      }
+    end
+
+    def add_reducer(reducer)
+      self.class.reducers.merge!(reducer)
+      next_reducer = Redux.combine_reducers(self.class.reducers)
+      replace_reducer(next_reducer)
+    end
+
+    def add_reducers(new_reducers)
+      self.class.reducers.merge!(new_reducers)
+      next_reducer = Redux.combine_reducers(self.class.reducers)
+      replace_reducer(next_reducer)
+    end
+
+    def dispatch(action)
+      %x{
+        if (typeof action.$class === "function" && action.$class() == "Hash") {
+          action = action.$to_n();
+        }
+        this.native.dispatch(action);
+      }
+    end
+
+    def get_state
+      %x{
+        let res = this.native.getState();
+        if (typeof(res) === 'object' && !Array.isArray(res) && res !== null) {
+          return Opal.Hash.$new(res);
+        }
+        return res;
+      }
+    end
+
+    def recently_dispatched?
+      res = @dispatched
+      @dispatched = false
+      res
+    end
+
+    def collect_and_defer_dispatch(action)
+      if !Isomorfeus.on_ssr?
+        type = action.delete(:type)
+        @deferred_actions[type] = [] unless @deferred_actions.key?(type)
+        @deferred_actions[type].push(action)
+        @last_dispatch_time = `Date.now()`
+        # `console.log(#@last_dispatch_time)`
+        deferred_dispatcher(`Date.now()`) unless @deferred_dispatcher
+      else
+        @dispatched = true
+        dispatch(action)
+      end
+      nil
+    end
+
+    def replace_reducer(next_reducer)
+      `this.native.replaceReducer(next_reducer)`
+    end
+
+    # returns function needed to unsubscribe the listener
+    def subscribe(&listener)
+      `this.native.subscribe(function() { return listener.$call(); })`
+    end
+
+    private
+
+    def deferred_dispatcher(first)
+      @deferred_dispatcher = true
+      %x{
+        setTimeout(function() {
+          if (#{wait_longer?(first)}) { #{deferred_dispatcher(first)} }
+          else { #{dispatch_deferred_dispatches} }
+        }, 10)
+      }
+    end
+
+    def dispatch_deferred_dispatches
+      # `console.log(Date.now())`
+      @deferred_dispatcher = false
+      actions = @deferred_actions
+      @deferred_actions = {}
+      actions.each do |type, data|
+        dispatch(type: type, collected: data)
+      end
+    end
+
+    def wait_longer?(first)
+      t = `Date.now()`
+      time_since_first = `t - first`
+      # `console.log('delta', time_since_first)`
+      return true if `typeof Opal.Preact !== 'undefined' && typeof Opal.Preact.render_buffer !== 'undefined' && Opal.Preact.render_buffer.length > 0 && time_since_first < 1000`
+      return false if time_since_first > 100 # ms
+      return false if (`t - #@last_dispatch_time`) > 9 # ms
+      return true
+    end
+  end
+end

data/lib/redux/version.rb

@@ -1,3 +1,3 @@
-module Redux
-  VERSION = '4.1.13'
-end
+module Redux
+  VERSION = '4.1.17'
+end

data/lib/redux.rb

@@ -1,112 +1,118 @@
 module Redux
-  def self.create_store(reducer, preloaded_state = nil, enhancer = nil)
-    Redux::Store.new(reducer, preloaded_state, enhancer)
-  end
+  class << self
+    def create_store(reducer, preloaded_state = nil, enhancer = nil)
+      Redux::Store.new(reducer, preloaded_state, enhancer)
+    end
 
-  def self.combine_reducers(reducers)
-    %x{
-      var real_reducers;
-      if (typeof reducers.$class === "function") {
-        real_reducers = reducers.$to_n();
-      } else {
-        real_reducers = reducers;
+    def combine_reducers(reducers)
+      %x{
+        if (typeof reducers.$to_n === "function") {
+          reducers = reducers.$to_n();
+        }
+        return Opal.global.Redux.combineReducers(reducers);
       }
-      return Opal.global.Redux.combineReducers(real_reducers);
-    }
-  end
+    end
 
-  def self.apply_middleware(*middlewares)
-    if middlewares.size == 1
-      `Opal.global.Redux.applyMiddleware.apply(null, middlewares[0])`
-    else
-      `Opal.global.Redux.applyMiddleware.apply(null, middlewares)`
+    def apply_middleware(*middlewares)
+      if middlewares.size == 1
+        `Opal.global.Redux.applyMiddleware.apply(null, middlewares[0])`
+      else
+        `Opal.global.Redux.applyMiddleware.apply(null, middlewares)`
+      end
     end
-  end
 
-  def self.bind_action_creators(*args)
-    dispatch = args.pop
-    `Opal.global.Redux.bindActionCreators(args, dispatch)`
-  end
+    def bind_action_creators(*args)
+      dispatch = args.pop
+      `Opal.global.Redux.bindActionCreators(args, dispatch)`
+    end
 
-  def self.compose(*functions)
-    `Opal.global.Redux.compose(functions)`
-  end
+    def compose(*functions)
+      `Opal.global.Redux.compose(functions)`
+    end
 
-  def self.create_reducer(&block)
-    %x{
-      return (function(previous_state, action) {
-        if (!previous_state) { previous_state = {}; }
-        var previous_state_hash = Opal.Hash.$new(previous_state);
-        var new_state_hash = block.$call(previous_state_hash, Opal.Hash.$new(action));
-        if (previous_state_hash === new_state_hash) { return previous_state; }
-        if (typeof new_state_hash.$class === "function") { return new_state_hash.$to_n(); }
-        return previous_state;
-      });
-    }
-  end
+    def create_reducer(&block)
+      %x{
+        return function(previous_state, action) {
+          let state = null;
+          if (previous_state === null || typeof(previous_state) === 'undefined') { state = nil; }
+          else if (typeof(previous_state) === 'object' && !Array.isArray(previous_state)) {
+            state = Opal.Hash.$new(previous_state);
+          } else { state = previous_state; }
+          var new_state = block.$call(state, Opal.Hash.$new(action));
+          if (typeof(previous_state) === 'undefined' || previous_state === null) {
+            if (typeof(new_state.$to_n) === "function") { return new_state.$to_n(); }
+            return new_state;
+          }
+          if (state === new_state) { return previous_state; }
+          if (typeof(new_state.$to_n) === "function") { return new_state.$to_n(); }
+          return previous_state;
+        };
+      }
+    end
 
-  def self.delete_state_path(state, *path)
-    size = path.size - 1
-    set_state_path(state, *path[0..-2], nil)
-    (2...size).each do |i|
-      val = get_state_path(state, *path[0..-i])
-      break if val.keys.size > 1
-      set_state_path(state, *path[0..-i], nil)
+    def delete_state_path(state, *path)
+      size = path.size - 1
+      set_state_path(state, *path[0..-2], nil)
+      (2...size).each do |i|
+        val = get_state_path(state, *path[0..-i])
+        break if val.keys.size > 1
+        set_state_path(state, *path[0..-i], nil)
+      end
     end
-  end
 
-  def self.fetch_by_path(*path)
-    # get active redux component
-    %x{
-      var active_component = Opal.Preact.active_redux_component();
-      var current_state;
-      var final_data;
-      var path_last = path.length - 1;
-      if (path[path_last].constructor === Array) {
-        path[path_last] = JSON.stringify(path[path_last]);
-      }
-      if (active_component) {
-        // try to get data from component state or props or store
-        current_state = active_component.data_access()
-        if (current_state) {
+    def fetch_by_path(*path)
+      # get active redux component
+      %x{
+        var active_component = Opal.Preact.active_redux_component();
+        var current_state;
+        var final_data;
+        var path_last = path.length - 1;
+        if (path[path_last].constructor === Array) {
+          path[path_last] = JSON.stringify(path[path_last]);
+        }
+        if (active_component) {
+          // try to get data from component state or props or store
+          current_state = active_component.data_access()
+          if (current_state) {
+            final_data = path.reduce(function(prev, curr) { return prev && prev[curr]; }, current_state);
+            // if final data doesn't exist, 'null' is returned, so nil or false are ok as final_data
+            if (final_data !== null && typeof final_data !== "undefined") { return final_data; }
+          }
+        } else {
+          // try to get data from store
+          current_state = Opal.Isomorfeus.store.native.getState();
           final_data = path.reduce(function(prev, curr) { return prev && prev[curr]; }, current_state);
           // if final data doesn't exist, 'null' is returned, so nil or false are ok as final_data
           if (final_data !== null && typeof final_data !== "undefined") { return final_data; }
         }
-      } else {
-        // try to get data from store
-        current_state = Opal.Isomorfeus.store.native.getState();
-        final_data = path.reduce(function(prev, curr) { return prev && prev[curr]; }, current_state);
-        // if final data doesn't exist, 'null' is returned, so nil or false are ok as final_data
-        if (final_data !== null && typeof final_data !== "undefined") { return final_data; }
+        return null;
       }
-      return null;
-    }
-  end
+    end
 
-  def self.get_state_path(state, *path)
-    path.inject(state) do |state_el, path_el|
-      if state_el.key?(path_el)
-        state_el[path_el]
-      else
-        return nil
+    def get_state_path(state, *path)
+      path.inject(state) do |state_el, path_el|
+        if state_el.key?(path_el)
+          state_el[path_el]
+        else
+          return nil
+        end
       end
     end
-  end
 
-  def self.set_state_path(state, *path, value)
-    last_el = path.last
-    path.inject(state) do |state_el, path_el|
-      if path_el == last_el
-        state_el[path_el] = value
-        state_el[path_el]
-      elsif !state_el.key?(path_el)
-        state_el[path_el] = {}
-        state_el[path_el]
-      else
-        state_el[path_el]
+    def set_state_path(state, *path, value)
+      last_el = path.last
+      path.inject(state) do |state_el, path_el|
+        if path_el == last_el
+          state_el[path_el] = value
+          state_el[path_el]
+        elsif !state_el.key?(path_el)
+          state_el[path_el] = {}
+          state_el[path_el]
+        else
+          state_el[path_el]
+        end
       end
+      nil
     end
-    nil
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: isomorfeus-redux
 version: !ruby/object:Gem::Version
-  version: 4.1.13
+  version: 4.1.17
 platform: ruby
 authors:
 - Jan Biedermann
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-02-08 00:00:00.000000000 Z
+date: 2022-02-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: opal
@@ -30,28 +30,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.14.8
+        version: 0.14.10
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.14.8
+        version: 0.14.10
 - !ruby/object:Gem::Dependency
   name: isomorfeus-speednode
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.4.8
+        version: 0.4.9
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.4.8
+        version: 0.4.9
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement