react-rails 1.9.0 → 3.2.1

data/lib/react/jsx/babel_transformer.rb

@@ -1,21 +1,27 @@
-require 'babel/transpiler'
+# frozen_string_literal: true
+
+require "babel/transpiler"
 module React
   module JSX
     # A {React::JSX}-compliant transformer which uses `Babel::Transpiler` to transform JSX.
     class BabelTransformer
-      DEPRECATED_OPTIONS = [:harmony, :strip_types, :asset_path]
-      DEFAULT_TRANSFORM_OPTIONS = { blacklist: ['spec.functionName', 'validation.react', 'strict'] }
+      DEPRECATED_OPTIONS = %i[harmony strip_types asset_path].freeze
+      DEFAULT_TRANSFORM_OPTIONS = { blacklist: ["spec.functionName", "validation.react", "strict"] }.freeze
       def initialize(options)
         if (options.keys & DEPRECATED_OPTIONS).any?
-          ActiveSupport::Deprecation.warn("Setting config.react.jsx_transform_options for :harmony, :strip_types, and :asset_path keys is now deprecated and has no effect with the default Babel Transformer."+
-                                              "Please use new Babel Transformer options :whitelist, :plugin instead.")
+          ActiveSupport::Deprecation.warn(
+            <<-MSG
+              Setting config.react.jsx_transform_options for :harmony, :strip_types, and :asset_path keys is now deprecated and has no effect with the default Babel Transformer.
+              Please use new Babel Transformer options :whitelist, :plugin instead.
+            MSG
+          )
         end
 
         @transform_options = DEFAULT_TRANSFORM_OPTIONS.merge(options)
       end
 
       def transform(code)
-        Babel::Transpiler.transform(code, @transform_options)['code']
+        Babel::Transpiler.transform(code, @transform_options)["code"]
       end
     end
   end

data/lib/react/jsx/jsx_transformer.rb

@@ -1,31 +1,32 @@
+# frozen_string_literal: true
+
 module React
   module JSX
     # A {React::JSX}-compliant transformer which uses the deprecated `JSXTransformer.js` to transform JSX.
     class JSXTransformer
-      DEFAULT_ASSET_PATH = 'JSXTransformer.js'
+      DEFAULT_ASSET_PATH = "JSXTransformer.js"
 
       def initialize(options)
         @transform_options = {
           stripTypes: options.fetch(:strip_types, false),
-          harmony:    options.fetch(:harmony, false),
+          harmony: options.fetch(:harmony, false)
         }
 
         @asset_path = options.fetch(:asset_path, DEFAULT_ASSET_PATH)
 
         # If execjs uses therubyracer, there is no 'global'. Make sure
         # we have it so JSX script can work properly.
-        js_code = 'var global = global || this;' + jsx_transform_code
+        js_code = "var global = global || this;#{jsx_transform_code}"
         @context = ExecJS.compile(js_code)
       end
 
-
       def transform(code)
-        result = @context.call('JSXTransformer.transform', code, @transform_options)
+        result = @context.call("JSXTransformer.transform", code, @transform_options)
         result["code"]
       end
 
       # search for transformer file using sprockets - allows user to override
-      # this file in his own application
+      # this file in their own application
       def jsx_transform_code
         ::Rails.application.assets[@asset_path].to_s
       end

data/lib/react/jsx/processor.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module React
   module JSX
     # A Sprockets 3+-compliant processor
     class Processor
       def self.call(input)
-        JSX::transform(input[:data])
+        JSX.transform(input[:data])
       end
     end
   end

data/lib/react/jsx/sprockets_strategy.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module React
   module JSX
     # Depending on the Sprockets version,
@@ -17,13 +19,13 @@ module React
       # @param [Symbol, Nil] A strategy name, or `nil` to detect a strategy
       def attach_with_strategy(sprockets_env, strategy_or_nil)
         strategy = strategy_or_nil || detect_strategy
-        self.public_send(strategy, sprockets_env)
+        public_send(strategy, sprockets_env)
       end
 
       # @return [Symbol] based on the environment, return a method name to call with the sprockets environment
       def detect_strategy
         sprockets_version = Gem::Version.new(Sprockets::VERSION)
-        if sprockets_version >= Gem::Version.new("4.x")
+        if sprockets_version >= Gem::Version.new("4.a")
           :register_processors
         elsif sprockets_version >= Gem::Version.new("3.0.0")
           :register_engine_with_mime_type
@@ -37,16 +39,20 @@ module React
       end
 
       def register_engine_with_mime_type(sprockets_env)
-        sprockets_env.register_engine(".jsx", React::JSX::Processor, mime_type: "application/javascript", silence_deprecation: true)
+        sprockets_env.register_engine(".jsx", React::JSX::Processor, mime_type: "application/javascript",
+                                                                     silence_deprecation: true)
       end
 
       def register_processors(sprockets_env)
         sprockets_env.register_mime_type("application/jsx", extensions: [".jsx", ".js.jsx", ".es.jsx", ".es6.jsx"])
         sprockets_env.register_mime_type("application/jsx+coffee", extensions: [".jsx.coffee", ".js.jsx.coffee"])
         sprockets_env.register_transformer("application/jsx", "application/javascript", React::JSX::Processor)
-        sprockets_env.register_transformer("application/jsx+coffee", "application/jsx", Sprockets::CoffeeScriptProcessor)
-        sprockets_env.register_preprocessor("application/jsx", Sprockets::DirectiveProcessor.new(comments: ["//", ["/*", "*/"]]))
-        sprockets_env.register_preprocessor("application/jsx+coffee", Sprockets::DirectiveProcessor.new(comments: ["#", ["###", "###"]]))
+        sprockets_env.register_transformer("application/jsx+coffee", "application/jsx",
+                                           Sprockets::CoffeeScriptProcessor)
+        sprockets_env.register_preprocessor("application/jsx",
+                                            Sprockets::DirectiveProcessor.new(comments: ["//", ["/*", "*/"]]))
+        sprockets_env.register_preprocessor("application/jsx+coffee",
+                                            Sprockets::DirectiveProcessor.new(comments: ["#", ["###", "###"]]))
       end
     end
   end

data/lib/react/jsx/template.rb

@@ -1,16 +1,17 @@
-require 'tilt'
+# frozen_string_literal: true
+
+require "tilt"
 
 module React
   module JSX
     # Sprockets 2-compliant processor
     class Template < Tilt::Template
-      self.default_mime_type = 'application/javascript'
+      self.default_mime_type = "application/javascript"
 
-      def prepare
-      end
+      def prepare; end
 
-      def evaluate(scope, locals, &block)
-        @output ||= JSX::transform(data)
+      def evaluate(_scope, _locals)
+        @evaluate ||= JSX.transform(data)
       end
     end
   end

data/lib/react/jsx.rb

@@ -1,10 +1,12 @@
-require 'execjs'
-require 'react/jsx/processor'
-require 'react/jsx/template'
-require 'react/jsx/jsx_transformer'
-require 'react/jsx/babel_transformer'
-require 'react/jsx/sprockets_strategy'
-require 'rails'
+# frozen_string_literal: true
+
+require "execjs"
+require "react/jsx/processor"
+require "react/jsx/template"
+require "react/jsx/jsx_transformer"
+require "react/jsx/babel_transformer"
+require "react/jsx/sprockets_strategy"
+require "rails"
 
 module React
   module JSX
@@ -17,6 +19,8 @@ module React
     # - #transform(code) => new code
     self.transformer_class = DEFAULT_TRANSFORMER
 
+    # @param code [String] JSX code to transform into JavaScript
+    # @return [String] plain, browser-ready JavaScript code
     def self.transform(code)
       self.transformer ||= transformer_class.new(transform_options)
       self.transformer.transform(code)

data/lib/react/rails/asset_variant.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module React
   module Rails
     # This class accepts some options for which build you want, then exposes where you can find
     # them. In general, these paths should be added to the sprockets environment.
     class AssetVariant
-      GEM_ROOT = Pathname.new('../../../../').expand_path(__FILE__)
+      GEM_ROOT = Pathname.new("../../../../").expand_path(__FILE__)
       # @return [String] "production" or "development"
       attr_reader :react_build
 
@@ -15,14 +17,11 @@ module React
 
       # @param [Hash] Options for the asset variant
       # @option variant [Symbol] if `:production`, use the minified React.js build
-      # @option addons [Boolean] if true, use a React.js build with all addons
-      def initialize(options={})
-
-        @react_build = options[:variant] == :production ? 'production' : 'development'
-        options[:addons] && @react_build += '-with-addons'
+      def initialize(options = {})
+        @react_build = options[:variant] == :production ? "production" : "development"
 
-        @react_directory = GEM_ROOT.join('lib/assets/react-source/').join(@react_build).to_s
-        @jsx_directory =   GEM_ROOT.join('lib/assets/javascripts/').to_s
+        @react_directory = GEM_ROOT.join("lib/assets/react-source/").join(@react_build).to_s
+        @jsx_directory =   GEM_ROOT.join("lib/assets/javascripts/").to_s
       end
     end
   end

data/lib/react/rails/component_mount.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module React
   module Rails
     # This is the default view helper implementation.
@@ -9,43 +11,75 @@ module React
       include ActionView::Helpers::TagHelper
       include ActionView::Helpers::TextHelper
       attr_accessor :output_buffer
+
       mattr_accessor :camelize_props_switch
 
-      # ControllerLifecycle calls these hooks
-      # You can use them in custom helper implementations
-      def setup(env)
+      def initialize
+        @cache_ids = []
       end
 
-      def teardown(env)
+      # {ControllerLifecycle} calls these hooks
+      # You can use them in custom helper implementations
+      def setup(controller)
+        @controller = controller
       end
 
+      def teardown(controller); end
+
       # Render a UJS-type HTML tag annotated with data attributes, which
       # are used by react_ujs to actually instantiate the React component
       # on the client.
       def react_component(name, props = {}, options = {}, &block)
-        options = {:tag => options} if options.is_a?(Symbol)
-        if camelize_props_switch
-          props = React.camelize_props(props)
-        end
+        options = { tag: options } if options.is_a?(Symbol)
+        props = React.camelize_props(props) if options.fetch(:camelize_props, camelize_props_switch)
 
         prerender_options = options[:prerender]
-        if prerender_options
-          block = Proc.new{ concat React::ServerRendering.render(name, props, prerender_options) }
-        end
+        block = proc { concat(prerender_component(name, props, prerender_options)) } if prerender_options
+
+        html_options = generate_html_options(name, options, props, prerender_options)
+
+        rendered_tag(html_options, &block)
+      end
+
+      private
+
+      # If this controller has checked out a renderer, use that one.
+      # Otherwise, use {React::ServerRendering} directly (which will check one out for this rendering).
+      def prerender_component(component_name, props, prerender_options)
+        renderer = @controller.try(:react_rails_prerenderer) || React::ServerRendering
+        renderer.render(component_name, props, prerender_options)
+      end
+
+      def generate_html_options(name, options, props, prerender_options)
+        html_options = options.reverse_merge(data: {})
 
-        html_options = options.reverse_merge(:data => {})
         unless prerender_options == :static
           html_options[:data].tap do |data|
             data[:react_class] = name
             data[:react_props] = (props.is_a?(String) ? props : props.to_json)
+            data[:hydrate] = "t" if prerender_options
+
+            num_components = @cache_ids.count { |c| c.start_with? name }
+            data[:react_cache_id] = "#{name}-#{num_components}"
           end
         end
+
+        html_options
+      end
+
+      def rendered_tag(html_options, &block)
         html_tag = html_options[:tag] || :div
 
         # remove internally used properties so they aren't rendered to DOM
-        html_options.except!(:tag, :prerender)
+        html_option_to_use = html_options.except(:tag, :prerender, :camelize_props)
+
+        tag = content_tag(html_tag, "", html_option_to_use, &block)
+        return tag unless React::ServerRendering.renderer_options[:replay_console]
 
-        content_tag(html_tag, '', html_options, &block)
+        # Grab the server-rendered console replay script
+        # and move it _outside_ the container div
+        tag.sub!(%r{\n(<script class="react-rails-console-replay">.*</script>)</(\w+)>$}m, '</\2>\1')
+        tag.html_safe
       end
     end
   end

data/lib/react/rails/controller_lifecycle.rb

@@ -1,25 +1,54 @@
+# frozen_string_literal: true
+
 module React
   module Rails
+    # This module is included into ActionController so that
+    # per-request hooks can be called in the view helper.
     module ControllerLifecycle
       extend ActiveSupport::Concern
 
       included do
         # use both names to support Rails 3..5
-        before_action_with_fallback = respond_to?(:before_action) ? :before_action : :before_filter
-        after_action_with_fallback = respond_to?(:after_action) ? :after_action : :after_filter
-        public_send(before_action_with_fallback, :setup_react_component_helper)
-        public_send(after_action_with_fallback, :teardown_react_component_helper)
+        around_action_with_fallback = respond_to?(:around_action) ? :around_action : :around_filter
+        public_send(around_action_with_fallback, :use_react_component_helper)
         attr_reader :__react_component_helper
       end
 
-      def setup_react_component_helper
+      module ClassMethods
+        # Call this in the controller to check out a prerender for the whole request.
+        # You can access the renderer with {#react_rails_prerenderer}.
+        def per_request_react_rails_prerenderer
+          around_action_with_fallback = respond_to?(:around_action) ? :around_action : :around_filter
+          public_send(around_action_with_fallback, :per_request_react_rails_prerenderer)
+        end
+      end
+
+      # Instantiate the ViewHelper implementation and call its #setup method
+      # then let the controller action run,
+      # then call the ViewHelper implementation's #teardown method
+      def use_react_component_helper
         new_helper = React::Rails::ViewHelper.helper_implementation_class.new
         new_helper.setup(self)
         @__react_component_helper = new_helper
+        yield
+        @__react_component_helper.teardown(self)
       end
 
-      def teardown_react_component_helper
-        @__react_component_helper.teardown(self)
+      # If you want a per-request renderer, add this method as an around-action
+      #
+      # (`.per_request_react_rails_prerenderer` does this for you)
+      # @example Having one renderer instance for each controller action
+      #   around_action :per_request_react_rails_prerenderer
+      def per_request_react_rails_prerenderer
+        React::ServerRendering.with_renderer do |renderer|
+          @__react_rails_prerenderer = renderer
+          yield
+        end
+      end
+
+      # An instance of a server renderer, for use during this request
+      def react_rails_prerenderer
+        @__react_rails_prerenderer
       end
     end
   end

data/lib/react/rails/controller_renderer.rb

@@ -1,9 +1,12 @@
+# frozen_string_literal: true
+
 module React
   module Rails
     # A renderer class suitable for `ActionController::Renderers`.
     # It is associated to `:component` in the Railtie.
     #
-    # It is prerendered with {React::ServerRendering}.
+    # It is prerendered by default with {React::ServerRendering}.
+    # Set options[:prerender] to `false` to disable prerendering.
     #
     # @example Rendering a component from a controller
     #   class TodosController < ApplicationController
@@ -19,17 +22,23 @@ module React
 
       attr_accessor :output_buffer
 
-      def initialize(options={})
+      def initialize(options = {})
         controller = options[:controller]
         @__react_component_helper = controller.__react_component_helper
       end
 
-      # @return [String] Prerendered HTML for `component_name` with `options[:props]`
+      # @return [String] HTML for `component_name` with `options[:props]`
       def call(component_name, options, &block)
         props = options.fetch(:props, {})
-        options = options.slice(:data, :aria, :tag, :class, :id).merge(prerender: true)
+        options = default_options.merge(options.slice(:data, :aria, :tag, :class, :id, :prerender, :camelize_props))
         react_component(component_name, props, options, &block)
       end
+
+      private
+
+      def default_options
+        { prerender: true }
+      end
     end
   end
 end

data/lib/react/rails/railtie.rb

@@ -1,4 +1,6 @@
-require 'rails'
+# frozen_string_literal: true
+
+require "rails"
 
 module React
   module Rails
@@ -6,7 +8,6 @@ module React
       config.react = ActiveSupport::OrderedOptions.new
       # Sensible defaults. Can be overridden in application.rb
       config.react.variant = (::Rails.env.production? ? :production : :development)
-      config.react.addons = false
       config.react.jsx_transform_options = {}
       config.react.jsx_transformer_class = nil # defaults to BabelTransformer
       config.react.camelize_props = false # pass in an underscored hash but get a camelized hash
@@ -15,19 +16,34 @@ module React
       # Server rendering:
       config.react.server_renderer_pool_size  = 1   # increase if you're on JRuby
       config.react.server_renderer_timeout    = 20  # seconds
-      config.react.server_renderer            = nil # defaults to SprocketsRenderer
-      config.react.server_renderer_options    = {}  # SprocketsRenderer provides defaults
+      config.react.server_renderer            = nil # defaults to BundleRenderer
+      config.react.server_renderer_options    = {}  # BundleRenderer provides defaults
+      # Changing files with these extensions in these directories will cause the server renderer to reload:
+      config.react.server_renderer_directories = ["/app/assets/javascripts/", "app/javascript"]
+      config.react.server_renderer_extensions = %w[jsx js]
       # View helper implementation:
       config.react.view_helper_implementation = nil # Defaults to ComponentMount
 
       # Watch .jsx files for changes in dev, so we can reload the JS VMs with the new JS code.
-      initializer "react_rails.add_watchable_files", group: :all do |app|
-        app.config.watchable_files.concat Dir["#{app.root}/app/assets/javascripts/**/*.jsx*"]
+      initializer "react_rails.add_watchable_files", after: :load_config_initializers, group: :all do |app|
+        # Watch files ending in `server_renderer_extensions` in each of `server_renderer_directories`
+        reload_paths = config.react.server_renderer_directories.each_with_object({}) do |dir, memo|
+          app_dir = File.join(app.root, dir)
+          memo[app_dir] = config.react.server_renderer_extensions
+        end
+
+        # Rails checks these objects for changes:
+        react_reloader = app.config.file_watcher.new([], reload_paths) do
+          React::ServerRendering.reset_pool
+        end
+        app.reloaders << react_reloader
+
+        # Reload renderers in dev when files change
+        config.to_prepare { react_reloader.execute_if_updated }
       end
 
       # Include the react-rails view helper lazily
       initializer "react_rails.setup_view_helpers", after: :load_config_initializers, group: :all do |app|
-
         app.config.react.jsx_transformer_class ||= React::JSX::DEFAULT_TRANSFORMER
         React::JSX.transformer_class = app.config.react.jsx_transformer_class
         React::JSX.transform_options = app.config.react.jsx_transform_options
@@ -42,10 +58,11 @@ module React
 
         ActiveSupport.on_load(:action_view) do
           include ::React::Rails::ViewHelper
+          ActionDispatch::IntegrationTest.include React::Rails::TestHelper if ::Rails.env.test?
         end
       end
 
-      initializer "react_rails.add_component_renderer", group: :all do |app|
+      initializer "react_rails.add_component_renderer", group: :all do |_app|
         ActionController::Renderers.add :component do |component_name, options|
           renderer = ::React::Rails::ControllerRenderer.new(controller: self)
           html = renderer.call(component_name, options)
@@ -56,22 +73,19 @@ module React
 
       initializer "react_rails.bust_cache", after: :load_config_initializers, group: :all do |app|
         asset_variant = React::Rails::AssetVariant.new({
-          variant: app.config.react.variant,
-          addons: app.config.react.addons,
-        })
+                                                         variant: app.config.react.variant
+                                                       })
 
         sprockets_env = app.assets || app.config.try(:assets) # sprockets-rails 3.x attaches this at a different config
-        if !sprockets_env.nil?
-          sprockets_env.version = [sprockets_env.version, "react-#{asset_variant.react_build}",].compact.join('-')
+        unless sprockets_env.nil?
+          sprockets_env.version = [sprockets_env.version, "react-#{asset_variant.react_build}"].compact.join("-")
         end
-
       end
 
       initializer "react_rails.set_variant", after: :engines_blank_point, group: :all do |app|
         asset_variant = React::Rails::AssetVariant.new({
-          variant: app.config.react.variant,
-          addons: app.config.react.addons,
-        })
+                                                         variant: app.config.react.variant
+                                                       })
 
         if app.config.respond_to?(:assets)
           app.config.assets.paths << asset_variant.react_directory
@@ -81,32 +95,23 @@ module React
 
       config.after_initialize do |app|
         # The class isn't accessible in the configure block, so assign it here if it wasn't overridden:
-        app.config.react.server_renderer ||= React::ServerRendering::SprocketsRenderer
+        app.config.react.server_renderer ||= React::ServerRendering::BundleRenderer
 
         React::ServerRendering.pool_size        = app.config.react.server_renderer_pool_size
         React::ServerRendering.pool_timeout     = app.config.react.server_renderer_timeout
         React::ServerRendering.renderer_options = app.config.react.server_renderer_options
         React::ServerRendering.renderer         = app.config.react.server_renderer
-
         React::ServerRendering.reset_pool
-        # Reload renderers in dev when files change
-        if Gem::Version.new(::Rails::VERSION::STRING) >= Gem::Version.new("5.x")
-          ActiveSupport::Reloader.to_prepare { React::ServerRendering.reset_pool }
-        else
-          ActionDispatch::Reloader.to_prepare { React::ServerRendering.reset_pool }
-        end
       end
 
-      initializer "react_rails.setup_engine", :group => :all do |app|
+      initializer "react_rails.setup_engine", group: :all do |app|
         # Sprockets 3.x expects this in a different place
-        sprockets_env = app.assets || defined?(Sprockets) && Sprockets
+        sprockets_env = app.assets || (defined?(Sprockets) && Sprockets)
 
         if app.config.react.sprockets_strategy == false
           # pass, Sprockets opt-out
         elsif sprockets_env.present?
           React::JSX::SprocketsStrategy.attach_with_strategy(sprockets_env, app.config.react.sprockets_strategy)
-        else
-          # pass, Sprockets is not preset
         end
       end
     end

data/lib/react/rails/test_helper.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module React
+  module Rails
+    module TestHelper
+      extend ActiveSupport::Concern
+
+      # assert react_component render
+      #
+      # assert_react_component("HelloWorld") do |props|
+      #   assert_equal "Hello world", props[:message]
+      # end
+      def assert_react_component(name)
+        assert_select "div[data-react-class=?]", name do |dom|
+          if block_given?
+            props = JSON.parse(dom.attr("data-react-props"))
+            props.deep_symbolize_keys!
+
+            yield(props)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/react/rails/version.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 module React
   module Rails
     # If you change this, make sure to update VERSIONS.md
-    # And the version hint in README.md, if needed
-    VERSION = "1.9.0"
+    # and republish the UJS by updating package.json and `bundle exec rake ujs:publish`
+    VERSION = "3.2.1"
   end
 end

data/lib/react/rails/view_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module React
   module Rails
     module ViewHelper
@@ -18,7 +20,7 @@ module React
       # Otherwise, make a new instance.
       def react_component(*args, &block)
         helper_obj = @__react_component_helper ||= helper_implementation_class.new
-        helper_obj.react_component(*args, &block)
+        helper_obj.react_component(*args) { capture(&block) if block }
       end
     end
   end

data/lib/react/rails.rb

@@ -1,7 +1,9 @@
-require 'react/rails/asset_variant'
-require 'react/rails/railtie'
-require 'react/rails/controller_lifecycle'
-require 'react/rails/version'
-require 'react/rails/component_mount'
-require 'react/rails/view_helper'
-require 'react/rails/controller_renderer'
+# frozen_string_literal: true
+
+require "react/rails/asset_variant"
+require "react/rails/railtie"
+require "react/rails/controller_lifecycle"
+require "react/rails/version"
+require "react/rails/component_mount"
+require "react/rails/view_helper"
+require "react/rails/controller_renderer"

data/lib/react/server_rendering/{sprockets_renderer → bundle_renderer}/console_replay.js

@@ -1,6 +1,6 @@
 (function (history) {
   if (history && history.length > 0) {
-    result += '\n<scr'+'ipt>';
+    result += '\n<scr'+'ipt class="react-rails-console-replay">';
     history.forEach(function (msg) {
       result += '\nconsole.' + msg.level + '.apply(console, ' + JSON.stringify(msg.arguments) + ');';
     });

data/lib/react/server_rendering/bundle_renderer/console_reset.js

@@ -0,0 +1,3 @@
+if (typeof console !== "undefined" && console.history) {
+  console.history = [];
+}