isomorfeus-redux 4.2.0 → 22.9.0.rc2

data/lib/redux/store.rb

@@ -1,11 +1,19 @@
 module Redux
   class Store
-    include Native::Wrapper
+    ACTIONS = {
+      init: "@@redux/INIT#{SecureRandom.hex(8)}",
+      replace: "@@redux/REPLACE#{SecureRandom.hex(8)}"
+    }
+    MIDDLEWARE_WARNING = "Adding middleware after Store initialization may have side effects! Saving state and initializing new store with restored state!"
 
     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!")`
+          if RUBY_ENGINE == 'opal'
+            `console.warning(#{MIDDLEWARE_WARNING})`
+          else
+            STDERR.puts MIDDLEWARE_WARNING
+          end
           middlewares << middleware
           preloaded_state = Isomorfeus.store.get_state
           init!
@@ -14,38 +22,19 @@ module Redux
         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
+          reducers.merge!(new_reducers)
         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
+        Redux::Store.new(reducers, preloaded_state, middlewares)
       end
 
       def middlewares
@@ -69,69 +58,71 @@ module Redux
       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.legacy_createStore(reducer, preloaded_state, enhancer);
-        } else if (preloaded_state) {
-          this.native = ogre.legacy_createStore(reducer, preloaded_state);
-        } else if (enhancer) {
-          this.native = ogre.legacy_createStore(reducer, enhancer);
-        } else {
-          this.native = ogre.legacy_createStore(reducer);
-        }
-      }
-    end
-
-    def add_reducer(reducer)
-      self.class.reducers.merge!(reducer)
-      next_reducer = Redux.combine_reducers(self.class.reducers)
-      replace_reducer(next_reducer)
+    def initialize(reducers, preloaded_state = nil, middleware = nil)
+      @deferred_actions = []
+      @listeners = {}
+      @key = 0
+      @is_dispatching = false
+      @preloaded_state = preloaded_state
+      @current_state = @preloaded_state.deep_dup
+      @current_state = {} unless @current_state
+      init_reducers(reducers)
+      @middleware = middleware.dup
+      @middleware = [] unless middleware
+      if @middleware.empty?
+        @middleware = method(:reduce)
+      else
+        @middleware << proc { |action, _next_pr| reduce(action) }
+        @middleware = @middleware.reverse.reduce do |pr, next_pr|
+          proc do |action|
+            next_pr.call(action, pr)
+          end
+        end
+      end
+      @current_state_dup = @current_state.deep_dup
+      dispatch({ type: ACTIONS[:init] })
+    end
+
+    def clear!
+      @current_state = @preloaded_state.deep_dup
+      @current_state_dup = @current_state.deep_dup
+      @listeners = {}
+      nil
     end
 
     def add_reducers(new_reducers)
-      self.class.reducers.merge!(new_reducers)
-      next_reducer = Redux.combine_reducers(self.class.reducers)
-      replace_reducer(next_reducer)
+      if @reducers
+        @reducers.merge!(new_reducers)
+      elsif @reducer
+        @current_state = { state: @current_state }
+        init_reducers({ state: @reducer }.merge!(new_reducers))
+      end
+      nil
+    end
+
+    def multi_dispatch(actions)
+      actions.each do |action|
+        single_dispatch(action)
+      end
+      @listeners.dup.each_value { |listener| listener.call }
+      actions
     end
 
     def dispatch(action)
-      %x{
-        if (typeof action.$class === "function" && action.$class() == "Hash") {
-          action = action.$to_n();
-        }
-        this.native.dispatch(action);
-      }
+      single_dispatch(action)
+      @listeners.dup.each_value { |listener| listener.call }
+      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;
-      }
+      if @is_dispatching
+        raise <<-MSG
+          You may not call store.get_state while the reducer is executing.
+          The reducer has already received the state as an argument.
+          Pass it down from the top reducer instead of reading it from the store."
+          MSG
+      end
+      return @current_state_dup
     end
 
     def recently_dispatched?
@@ -140,60 +131,105 @@ module Redux
       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
+    if RUBY_ENGINE == 'opal'
+      def deferred_dispatch(action)
+        @deferred_actions.push(action)
+        if @deferred_actions.length == 1
+          after(0) do
+            acts = @deferred_actions
+            @deferred_actions = []
+            multi_dispatch(acts)
+          end
+        end
+        nil
+      end
+    else # RUBY_ENGINE
+      def deferred_dispatch(action)
+        Isomorfeus.reset_something_loading
         dispatch(action)
+        nil
+      end
+    end # RUBY_ENGINE
+
+    def replace_reducer(next_reducer)
+      init_reducers(next_reducer)
+      dispatch({ type: ACTIONS[:replace] })
+    end
+
+    # returns key needed to unsubscribe the listener
+    def subscribe(listen_proc = nil, &listen_block)
+      if @is_dispatching
+        raise <<-MSG
+          You may not call store.subscribe while the reducer is executing.
+          If you would like to be notified after the store has been updated,
+          subscribe from a component and invoke store.get_state in the callback to access the latest state.
+          MSG
       end
+      listener = listen_proc || listen_block
+      raise "a block or proc must be given to subscribe" unless listener
+      @key += 1
+      @listeners[@key] = listener
+      @key
+    end
+
+    def unsubscribe(key)
+      return unless @listeners.key?(key)
+      if @is_dispatching
+        raise "You may not unsubscribe from a store listener while the reducer is executing."
+      end
+      @listeners.delete(key)
       nil
     end
 
-    def replace_reducer(next_reducer)
-      `this.native.replaceReducer(next_reducer)`
+    def dig(*path)
+      @current_state_dup.dig(*path)
     end
 
-    # returns function needed to unsubscribe the listener
-    def subscribe(&listener)
-      `this.native.subscribe(function() { return listener.$call(); })`
+    if RUBY_ENGINE == 'opal'
+      def promise_action(action)
+        Isomorfeus::Transport.promise_send_action(action).then do |agent|
+          agent&.process do
+            Isomorfeus.reset_something_loading
+            Isomorfeus.store.dispatch(type: 'REDUX_MERGE', state: agent.full_response[:state])
+          end
+        end
+      end
     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
+    def single_dispatch(action)
+      raise "Actions must be plain Hashes. Instead, the actual type was: '#{action.class}'." unless action.class == Hash
+      raise "Actions must have a :type key." unless action.key?(:type)
+      raise "Reducers may not dispatch actions." if @is_dispatching
+
+      begin
+        @is_dispatching = true
+        @middleware.call(action)
+      ensure
+        @is_dispatching = false
+      end
+
+      @current_state_dup = @current_state.deep_dup # duplicate state for get_state/dig until later on maybe we can #freeze
+    end
+
+    def init_reducers(reducers)
+      if reducers.is_a?(Hash) && reducers.any?
+        @reducers = reducers
+        @reducers.each do |key, red|
+          raise "reducer for :#{key} is not a proc" unless red.is_a?(Proc)
+          @current_state[key] = nil unless @current_state.key?(key)
+        end
+      else
+        raise "no reducer defined"
+      end
+    end
+
+    def reduce(action)
+      @reducers.each do |key, reducer|
+        @current_state[key] = reducer.call(@current_state_dup[key], action)
+      end
+      action
     end
   end
 end

data/lib/session_store.rb

@@ -2,40 +2,38 @@ class SessionStore
   extend Isomorfeus::BrowserStoreApi
 
   class << self
-    def method_missing(key, *args, &block)
-      if Isomorfeus.on_browser?
-        if `args.length > 0`
-          key = `key.endsWith('=')` ? key.chop : key
-          value = args[0]
-          `Opal.global.sessionStorage.setItem(key, value)`
-          notify_subscribers
-          value
-        else
-          # check store for value
-          value = `Opal.global.sessionStorage.getItem(key)`
-          return value if value
-        end
+    if RUBY_ENGINE == 'opal'
+      def [](key)
+        # check store for value
+        value = `Opal.global.sessionStorage.getItem(key)`
+        return nil if `value == null`
+        value
       end
-      # otherwise return nil
-      return nil
-    end
-
-    alias [] method_missing
-    alias []= method_missing
 
-    alias get method_missing
-    alias set method_missing
+      def []=(key, value)
+        `Opal.global.sessionStorage.setItem(key, value)`
+        notify_subscribers
+        value
+      end
 
-    def delete(key)
-      `Opal.global.sessionStorage.removeItem(key)`
-      notify_subscribers
-      nil
-    end
+      def delete(key)
+        `Opal.global.sessionStorage.removeItem(key)`
+        notify_subscribers
+        nil
+      end
 
-    def clear
-      `Opal.global.sessionStorage.clear()`
-      notify_subscribers
-      nil
+      def clear
+        `Opal.global.sessionStorage.clear()`
+        notify_subscribers
+        nil
+      end
+    else
+      def [](key); end
+      def []=(key, value); end
+      def delete(key); end
+      def clear; end
     end
+    alias get []
+    alias set []=
   end
 end