isomorfeus-asset-manager 0.14.11 → 0.14.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 78b774bc55cc59e8fee7021c0cad65221b01885e932f7881cf6f006e45898400
-  data.tar.gz: 76c7b73948ed055aeeca30847e307ef1e7ef7174075463abbfff04555e032df3
+  metadata.gz: 2d12a6934f43c1c263059200fe3fae784c11235faeee871bd439e71ec4bd4e40
+  data.tar.gz: e952047d1849071d3e46cb8f2a7b49039f8c60099d4e7f7877301ff9e3d2223a
 SHA512:
-  metadata.gz: 9e05e0fdb8f88f717638ba1aece5332d737e7e7e16f0262519386eebb4e92b21af5e31176e76dabed2d19afed09a3b8652922c0365c49625cac3e4827e72f722
-  data.tar.gz: 8a67ce45a8dad7badc69a5e4cff9d617ff0f5bd9e9316d369fc335e190793110696f684ac2289dd31874eeaba25d06e63dcd9f1d543870b7197d61168d813b96
+  metadata.gz: cc5328b6425a14068d993b276c67752e9a4658e37f036b7acc941022ea6be7136ed3c0a0f449e15af417c9c19810f60300a6c44b69fba458909e448d32aec605
+  data.tar.gz: e68a2ad8c0b69756b37f656f39befc1b8acee6ac9d792a583c8923adfbdf77b510f39b5bf188372f75c850d51569a2c64cc71ff958448a26917ab5d4c76a9f8b

data/README.md

@@ -6,10 +6,14 @@
 
 Convenient and well performing on demand asset bundling for the isomorfeus framework project, internally using esbuild (esbuild-wasm).
 
-Version follows esbuild version: 0.13.x comes with esbuild 0.13.y.
+Version follows esbuild version: 0.14.x comes with esbuild 0.14.y.
 
 No need to install esbuild separately, everything bundled ready to go.
 However, if within the project the 'esbuild' npm package is installed in node_modules, that version will be used instead.
 
 ### Community and Support
 At the [Isomorfeus Framework Project](https://isomorfeus.com)
+
+### Targets
+By default bundles for browsers using the 'es6' target of esbuild.
+By default bundles for node using the 'node16' target of esbuild.

data/lib/isomorfeus/asset_manager/asset.rb

@@ -1,180 +1,63 @@
 module Isomorfeus
   class AssetManager
     class Asset
-      attr_reader :bundle, :bundle_size
-      attr_reader :bundle_gz, :bundle_gz_size
-      attr_reader :bundle_map, :bundle_map_size
-      attr_reader :bundle_map_gz, :bundle_map_gz_size
-      attr_reader :bundle_ruby_modules
-      attr_reader :css, :css_size
-      attr_reader :css_gz, :css_gz_size
-      attr_reader :css_map, :css_map_size
-      attr_reader :css_map_gz, :css_map_gz_size
-      attr_reader :mtime, :ruby_imports, :target
-      attr_reader :mutex
+      class << self
+        alias_method :_original_new, :new
+        def new(target = :browser)
+          return BrowserAsset.new if target == :browser
+          return NodeAsset.new if target == :node
+          raise "unknown target #{traget}"
+        end
+      end
+
+      attr_reader :bundle_ruby_modules, :hash, :target
+      attr_reader :mtime, :js_imports, :ruby_imports, :mutex
 
       def initialize(target = :browser)
-        @mutex = Mutex.new
-        raise "Unknown asset target!" unless %i[browser node].include?(target)
         @target = target
+        @mutex = Mutex.new
         @bundled = false
-        @css_bundled = false
-        @ruby_compiled = false
+        @bundle_ruby_modules = {}
+        @hash = { css: {}, js: {}}
         @js_imports = []
         @ruby_imports = []
       end
 
-      def add_js_import(*args)
-        @js_imports << Isomorfeus::AssetManager::JsImport.new(*args)
+      def browser?
+        target == :browser
       end
 
-      def add_ruby_import(*args)
-        @ruby_imports << Isomorfeus::AssetManager::RubyImport.new(*args)
+      def node?
+        target == :node
       end
 
-      def bundle=(b)
-        @bundled = true
-        @bundle = b
-        @bundle_size = @bundle.size
-        unless @target == :node
-          @bundle_gz = Zlib::gzip(b, level: Zlib::BEST_COMPRESSION)
-          @bundle_gz_size = @bundle_gz.size
-        end
-        @bundle
+      def add_js_import(*args)
+        @js_imports << Isomorfeus::AssetManager::JsImport.new(*args)
       end
 
-      def bundle_map=(m)
-        @bundled = true
-        @bundle_map = m
-        unless @target == :node
-          @bundle_map_gz = Zlib::gzip(m, level: Zlib::BEST_COMPRESSION)
-          @bundle_map_gz_size = @bundle_map_gz.size
-        end
-        @bundle_map
+      def add_ruby_import(*args)
+        @ruby_imports << Isomorfeus::AssetManager::RubyImport.new(*args)
       end
 
-      def bundle_ruby_modules=(m)
-        @bundled = true
-        @bundle_ruby_modules = m
-        if !Isomorfeus.production? && @target != :node
-          @bundle_ruby_modules.each do |key, mod_hash|
-            mod_hash[:js_size] = mod_hash[:js].size
-            mod_hash[:js_gz] = Zlib::gzip(mod_hash[:js], level: Zlib::BEST_COMPRESSION)
-            mod_hash[:js_gz_size] = mod_hash[:js_gz].size
-            mod_hash[:map_size] = mod_hash[:map].size
-            mod_hash[:map_gz] = Zlib::gzip(mod_hash[:map], level: Zlib::BEST_COMPRESSION)
-            mod_hash[:map_gz_size] = mod_hash[:map_gz].size
-          end
-        end
-        @bundle_ruby_modules
+      def bundle
+        @hash[:js][:js][:raw]
       end
 
       def bundled?
         @bundled
       end
 
-      def css=(b)
+      def bundled!
         @bundled = true
-        if b
-          @has_css = true
-          @css = b
-          @css_size = @css.size
-          unless @target == :node
-            @css_gz = Zlib::gzip(b, level: Zlib::BEST_COMPRESSION)
-            @css_gz_size = @css_gz.size
-          end
-        end
-        @css
-      end
-
-      def css_map=(m)
-        @bundled = true
-        if m
-          @has_css = true
-          @css_map = m
-          @css_map_size = @css_map.size
-          unless @target == :node
-            @css_map_gz = Zlib::gzip(m, level: Zlib::BEST_COMPRESSION)
-            @css_map_gz_size = @css_map_gz.size
-          end
-        end
-        @css_map
-      end
-
-      def has_css?
-        @has_css
       end
 
-      def ruby_modules
-        @ruby_imports.map(&:module_name)
-      end
-
-      def ruby_imports_to_s(asset_name)
-        s = @ruby_imports.size - 1
-        return '' if s < 0
-        js = "async function iam_load_ruby_modules() {\n"
-        @ruby_imports.each do |import|
-          js << '  await ' << import.to_dev_s(asset_name)
-        end
-        js << "}\niam_load_ruby_modules();\n"
+      def unbundle!
+        @bundled = false
       end
 
       def touch
         @mtime = (Time.now.to_f * (10 ** 9)).to_i
       end
-
-      def to_s
-        js = @target == :node ? '' : "if (typeof globalThis !== 'undefined' && typeof global === 'undefined') { globalThis.global = globalThis; }\n"
-        unless @js_imports.empty?
-          js << "#{@js_imports.map(&:to_s).join("\n")}"
-        end
-        js << "\n" if !@js_imports.empty? && !@ruby_imports.empty?
-        unless @ruby_imports.empty?
-          if Isomorfeus.development? && @target == :browser
-            js << <<~JAVASCRIPT
-            // Isomorfeus Asset Manager HMR code begin
-            let ws_protocol = (window.location.protocol == 'https:') ? 'wss:' : 'ws:';
-            let ws_url = ws_protocol + '//' + window.location.host + "#{Isomorfeus.assets_websocket_path}";
-            let hmr_ws_fun = function() {
-              let hmr_ws = new WebSocket(ws_url);
-              hmr_ws.onopen = function(event) { console.log("Isomorfeus Asset Manager HMR socket connected"); }
-              hmr_ws.onmessage = function(event) {
-                let update = JSON.parse(event.data);
-                if (typeof update.error !== 'undefined') { console.error(update.error); return; }
-                if (typeof update.locale !== 'undefined') {
-                  console.log('Isomorfeus Asset Manager updating locale ', update.locale);
-                  try { Opal.Isomorfeus.I18n.Init.$reload_from_server(); }
-                  catch { console.log('Isomorfeus Asset Manager could not update locale ', update.locale) }
-                  return;
-                }
-                let start_index = 'Opal.modules[\\"'.length;
-                let end_index = update.javascript.indexOf('"', start_index);
-                let opal_module_name = update.javascript.substr(start_index, end_index - start_index);
-                console.log('Isomorfeus Asset Manager updating ', opal_module_name);
-                if (typeof Opal !== 'undefined' && typeof Opal.require_table !== "undefined" && Opal.require_table['corelib/module']) {
-                  try {
-                    eval(update.javascript);
-                    if (Opal.require_table[opal_module_name]) { Opal.load.call(Opal, opal_module_name); }
-                    else { Opal.require.call(Opal, opal_module_name); }
-                    Opal.Isomorfeus.$force_render();
-                  } catch (e) { console.error(e); return; }
-                }
-              };
-              hmr_ws.onclose = function(event) {
-                setTimeout(function() {
-                  console.log("Isomorfeus Asset Manager reconnecting HMR socket");
-                  hmr_ws_fun();
-                }, 2000);
-              };
-            }
-            hmr_ws_fun()
-            // Isomorfeus Asset Manager HMR code end
-            JAVASCRIPT
-          end
-          js << "#{@ruby_imports.map(&:to_s).join("\n")}" if Isomorfeus.production? || target == :node
-        end
-        js
-      end
     end
   end
 end

data/lib/isomorfeus/asset_manager/browser_asset.rb

@@ -0,0 +1,128 @@
+module Isomorfeus
+  class AssetManager
+    class BrowserAsset < Asset
+      def self.new
+        _original_new
+      end
+
+      def initialize(target = :browser)
+        super(:browser)
+      end
+
+      def browser?
+        true
+      end
+
+      def node?
+        false
+      end
+
+      def build_ruby_and_save(asset_key, asset_name, imports_path)
+        @ruby_imports.each do |ruby_import|
+          module_name = ruby_import.module_name
+          asset_dir = File.join(imports_path, asset_name)
+          out_file = File.join(asset_dir, "#{module_name}.rb.js")
+          next if Isomorfeus.production? && File.exist?(out_file)
+          result = Opal::Builder.build(ruby_import.resolved_path, { esm: true })
+          js = result.to_s
+          if Isomorfeus.production?
+            FileUtils.mkdir_p(asset_dir) unless Dir.exist?(asset_dir)
+            FileUtils.mkdir_p(File.join(*[asset_dir].concat(module_name.split('/')[0...-1]))) if module_name.include?('/')
+            File.write(out_file, js)
+          else
+            js << "\n//# sourceMappingURL=#{Isomorfeus.assets_path}/#{asset_name}/#{module_name}.rb.js.map\n"
+            @bundle_ruby_modules[module_name] = { js: { raw: js }, map: { raw: Oj.dump(result.source_map.as_json, mode: :strict) }}
+          end
+        end
+      end
+
+      def save_entry(asset_key, asset_name, imports_path)
+        entry = File.join(imports_path, asset_key)
+        File.write(entry, generate_entry(asset_name))
+        entry
+      end
+
+      def bundle_css(asset_name, output_path)
+        filename = File.join(output_path, asset_name + '.css')
+        @hash[:css][:css] = { raw: File.read(filename) } if File.exist?(filename)
+      end
+
+      def bundle_css_map(asset_name, output_path)
+        filename = File.join(output_path, asset_name + '.css.map')
+        @hash[:css][:map] = { raw: File.read(filename) } if File.exist?(filename)
+      end
+
+      def bundle_js(asset_key, asset_name, imports_path, output_path)
+        js = File.read(File.join(output_path, asset_key))
+        js << ruby_imports_to_s(asset_name, imports_path) unless Isomorfeus.production?
+        @hash[:js][:js] = { raw: js }
+      end
+
+      def bundle_js_map(asset_key, output_path)
+        filename = File.join(output_path, asset_key + '.map')
+        @hash[:js][:map] = { raw: File.read(filename) } if File.exist?(filename)
+      end
+
+      def ruby_imports_to_s(asset_name, out_dir)
+        s = @ruby_imports.size - 1
+        return '' if s < 0
+        js = "async function iam_load_ruby_modules() {\n"
+        @ruby_imports.each do |import|
+          js << import.to_dev_s(asset_name)
+        end
+        js << "}\niam_load_ruby_modules();\n"
+      end
+
+      def generate_entry(asset_name)
+        js = "if (typeof globalThis !== 'undefined' && typeof global === 'undefined') { globalThis.global = globalThis; }\n"
+        js << "#{@js_imports.map(&:to_s).join("\n")}"
+        if @ruby_imports.any?
+          if Isomorfeus.development?
+            js << <<~JAVASCRIPT
+            // Isomorfeus Asset Manager HMR code begin
+            let ws_protocol = (window.location.protocol == 'https:') ? 'wss:' : 'ws:';
+            let ws_url = ws_protocol + '//' + window.location.host + "#{Isomorfeus.hmr_websocket_path}";
+            let hmr_ws_fun = function() {
+              let hmr_ws = new WebSocket(ws_url);
+              hmr_ws.onopen = function(event) { console.log("Isomorfeus Asset Manager HMR socket connected"); }
+              hmr_ws.onmessage = function(event) {
+                let update = JSON.parse(event.data);
+                if (typeof update.error !== 'undefined') { console.error(update.error); return; }
+                if (typeof update.locale !== 'undefined') {
+                  console.log('Isomorfeus Asset Manager updating locale ', update.locale);
+                  try { Opal.Isomorfeus.I18n.Init.$reload_from_server(); }
+                  catch { console.log('Isomorfeus Asset Manager could not update locale ', update.locale) }
+                  return;
+                }
+                let start_index = 'Opal.modules[\\"'.length;
+                let end_index = update.javascript.indexOf('"', start_index);
+                let opal_module_name = update.javascript.substr(start_index, end_index - start_index);
+                console.log('Isomorfeus Asset Manager updating ', opal_module_name);
+                if (typeof Opal !== 'undefined' && typeof Opal.require_table !== "undefined" && Opal.require_table['corelib/module']) {
+                  try {
+                    window.eval(update.javascript);
+                    if (Opal.require_table[opal_module_name]) { Opal.load.call(Opal, opal_module_name); }
+                    else { Opal.require.call(Opal, opal_module_name); }
+                    Opal.Isomorfeus.$force_render();
+                  } catch (e) { console.error(e); return; }
+                }
+              };
+              hmr_ws.onclose = function(event) {
+                setTimeout(function() {
+                  console.log("Isomorfeus Asset Manager reconnecting HMR socket");
+                  hmr_ws_fun();
+                }, 2000);
+              };
+            }
+            hmr_ws_fun()
+            // Isomorfeus Asset Manager HMR code end
+            JAVASCRIPT
+          elsif Isomorfeus.production?
+            js << "#{@ruby_imports.map { |i| i.to_s(asset_name) }.join("\n")}"
+          end
+        end
+        js
+      end
+    end
+  end
+end

data/lib/isomorfeus/asset_manager/config.rb

@@ -8,7 +8,7 @@ module Isomorfeus
       attr_accessor :root
       attr_accessor :app_root
       attr_accessor :assets_path
-      attr_accessor :assets_websocket_path
+      attr_accessor :hmr_websocket_path
       attr_accessor :asset_manager_tmpdir
       attr_accessor :asset_manager_hmr_channel
       attr_accessor :asset_manager_hmr_dirs
@@ -67,7 +67,7 @@ module Isomorfeus
   self.hmr_listener = nil
   self.asset_manager_hmr_channel = :isomorfeus_asset_manager_module_updates
   self.asset_manager_hmr_dirs = %w[channels components data locales operations policies]
-  self.assets_websocket_path = '/_asset_manager_hmr_websocket'
+  self.hmr_websocket_path = '/_asset_manager_hmr_websocket'
   self.assets_path = '/assets'
   self.assets = {
     'web.js' => Isomorfeus::AssetManager::Asset.new(:browser),

data/lib/isomorfeus/asset_manager/node_asset.rb

@@ -0,0 +1,56 @@
+module Isomorfeus
+  class AssetManager
+    class NodeAsset < Asset
+      def self.new
+        _original_new
+      end
+
+      def initialize(target = :node)
+        super(:node)
+      end
+
+      def browser?
+        false
+      end
+
+      def node?
+        true
+      end
+
+      def bundle
+        @hash[:js][:js][:raw]
+      end
+
+      def build_ruby_and_save(asset_key, asset_name, imports_path)
+        @ruby_imports.each do |ruby_import|
+          module_name = ruby_import.module_name
+          asset_dir = File.join(imports_path, asset_name)
+          out_file = File.join(asset_dir, "#{module_name}.rb.js")
+          next if Isomorfeus.production? && File.exist?(out_file)
+          result = Opal::Builder.build(ruby_import.resolved_path, { esm: true })
+          FileUtils.mkdir_p(asset_dir) unless Dir.exist?(asset_dir)
+          FileUtils.mkdir_p(File.join(*[asset_dir].concat(module_name.split('/')[0...-1]))) if module_name.include?('/')
+          File.write(out_file, result.to_s)
+        end
+        nil
+      end
+
+      def save_entry(asset_key, asset_name, imports_path)
+        entry = File.join(imports_path, asset_key)
+        File.write(entry, generate_entry(asset_name))
+        entry
+      end
+
+      def bundle_js(asset_key, asset_name, imports_path, output_path)
+        js = File.read(File.join(output_path, asset_key))
+        @hash[:js][:js] = { raw: js }
+      end
+
+      def generate_entry(asset_name)
+        js = ''
+        js << "#{@js_imports.map(&:to_s).join("\n")}"
+        js << "#{@ruby_imports.map { |i| i.to_s(asset_name) }.join("\n")}"
+      end
+    end
+  end
+end

data/lib/isomorfeus/asset_manager/rack_middleware.rb

@@ -4,12 +4,13 @@ module Isomorfeus
   class AssetManager
     class RackMiddleware
       WS_RESPONSE = [0, {}, []].freeze
+      C_ENCODINGS = %w[br gzip].freeze
+
       attr_reader :asset_manager
 
       def initialize(app)
         @app = app
         @asset_manager = Isomorfeus::AssetManager.new
-        @compressible_types = %w[application/javascript text/javascript text/css]
         if Isomorfeus.assets_path.end_with?('/')
           @assets_path = Isomorfeus.assets_path
           @assets_path_size = @assets_path.size
@@ -32,20 +33,11 @@ module Isomorfeus
               asset_key += '.js'
               if Isomorfeus.assets.key?(asset_key)
                 asset = Isomorfeus.assets[asset_key]
-                if asset && asset.target != :node
-                  asset_manager.transition(asset_key, asset)
+                if asset && asset.browser?
                   if asset.bundle_ruby_modules.key?(module_name)
-                    headers = {}
-                    headers['Last-Modified'] = asset.mtime
-                    headers[Rack::CONTENT_TYPE] = 'application/javascript'
-                    if should_gzip?(env)
-                      headers['Content-Encoding'] = "gzip"
-                      headers[Rack::CONTENT_LENGTH] = asset.bundle_ruby_modules[module_name][:js_gz_size]
-                      return [200, headers, asset.bundle_ruby_modules[module_name][:js_gz]]
-                    else
-                      headers[Rack::CONTENT_LENGTH] = asset.bundle_ruby_modules[module_name][:js_size]
-                      return [200, headers, asset.bundle_ruby_modules[module_name][:js]]
-                    end
+                    headers = { Rack::CONTENT_TYPE => 'application/javascript' }
+                    asset_manager.transition(asset_key, asset)
+                    return [200, headers, get_content(env, headers, asset, asset_key, asset.bundle_ruby_modules[module_name][:js])]
                   end
                 end
               end
@@ -55,58 +47,32 @@ module Isomorfeus
               asset_key, module_name = asset_key_module_name.split('/')
               asset_key += '.js'
               asset = Isomorfeus.assets[asset_key]
-              if asset && asset.target != :node
-                asset_manager.transition(asset_key, asset) unless asset.bundled?
+              if asset && asset.browser?
                 if asset.bundle_ruby_modules.key?(module_name)
-                  headers = {}
-                  headers['Last-Modified'] = asset.mtime
-                  headers[Rack::CONTENT_TYPE] = 'application/json'
-                  if should_gzip?(env)
-                    headers['Content-Encoding'] = "gzip"
-                    headers[Rack::CONTENT_LENGTH] = asset.bundle_ruby_modules[module_name][:map_gz_size]
-                    return [200, headers, asset.bundle_ruby_modules[module_name][:map_gz]]
-                  else
-                    headers[Rack::CONTENT_LENGTH] = asset.bundle_ruby_modules[module_name][:map_size]
-                    return [200, headers, asset.bundle_ruby_modules[module_name][:map]]
-                  end
+                  headers = { Rack::CONTENT_TYPE => 'application/json' }
+                  asset_manager.transition(asset_key, asset)
+                  return [200, headers, get_content(env, headers, asset, asset_key, asset.bundle_ruby_modules[module_name][:map])]
                 end
               end
 
             elsif path_info.end_with?('.js.map')
               asset_key = path_info[@assets_path_size..-5]
               asset = Isomorfeus.assets[asset_key]
-              if asset && asset.target != :node
-                asset_manager.transition(asset_key, asset) unless asset.bundled?
-                headers = {}
-                headers['Last-Modified'] = asset.mtime
-                headers[Rack::CONTENT_TYPE] = 'application/json'
-                if should_gzip?(env)
-                  headers['Content-Encoding'] = "gzip"
-                  headers[Rack::CONTENT_LENGTH] = asset.bundle_map_gz_size
-                  return [200, headers, asset.bundle_map_gz]
-                else
-                  headers[Rack::CONTENT_LENGTH] = asset.bundle_map_size
-                  return [200, headers, asset.bundle_map]
-                end
+              if asset && asset.browser?
+                headers = { Rack::CONTENT_TYPE => 'application/json' }
+                asset_manager.transition(asset_key, asset)
+                return [200, headers, get_content(env, headers, asset, asset_key, asset.hash[:js][:map])]
               end
 
             elsif path_info.end_with?('.css.map')
               # get css source map
               asset_key = path_info[@assets_path_size..-9] + '.js'
               asset = Isomorfeus.assets[asset_key]
-              if asset && asset.target != :node
-                asset_manager.transition(asset_key, asset) unless asset.bundled?
-                headers = {}
-                headers['Last-Modified'] = asset.mtime
-                headers[Rack::CONTENT_TYPE] = 'application/json'
-                if should_gzip?(env)
-                  headers['Content-Encoding'] = "gzip"
-                  headers[Rack::CONTENT_LENGTH] = asset.css_map_gz_size
-                  return [200, headers, asset.css_map_gz]
-                else
-                  headers[Rack::CONTENT_LENGTH] = asset.css_map_size
-                  return [200, headers, asset.css_map]
-                end
+              if asset && asset.browser?
+                headers = { Rack::CONTENT_TYPE => 'application/json' }
+                asset_manager.transition(asset_key, asset)
+                content = get_content(env, headers, asset, asset_key, asset.hash[:css][:map])
+                return [200, headers, content]
               end
             end
           end
@@ -115,45 +81,26 @@ module Isomorfeus
             asset_key = path_info[@assets_path_size..-1]
             if Isomorfeus.assets.key?(asset_key)
               asset = Isomorfeus.assets[asset_key]
-              if asset && asset.target != :node
+              if asset && asset.browser?
+                headers = { Rack::CONTENT_TYPE => 'application/javascript' }
                 asset_manager.transition(asset_key, asset)
-                headers = {}
-                headers['Last-Modified'] = asset.mtime
-                headers[Rack::CONTENT_TYPE] = 'application/javascript'
-                if should_gzip?(env)
-                  headers['Content-Encoding'] = "gzip"
-                  headers[Rack::CONTENT_LENGTH] = asset.bundle_gz_size
-                  return [200, headers, asset.bundle_gz]
-                else
-                  headers[Rack::CONTENT_LENGTH] = asset.bundle_size
-                  return [200, headers, asset.bundle]
-                end
+                return [200, headers, get_content(env, headers, asset, asset_key, asset.hash[:js][:js])]
               end
             end
 
           elsif path_info.end_with?('.css')
-            # get css
             asset_key = path_info[@assets_path_size..-5] + '.js'
             asset = Isomorfeus.assets[asset_key]
-            if asset && asset.target != :node
+            if asset && asset.browser?
+              headers = { Rack::CONTENT_TYPE => 'text/css' }
               asset_manager.transition(asset_key, asset)
-              headers = {}
-              headers['Last-Modified'] = asset.mtime
-              headers[Rack::CONTENT_TYPE] = 'text/css'
-              if should_gzip?(env)
-                headers['Content-Encoding'] = "gzip"
-                headers[Rack::CONTENT_LENGTH] = asset.css_gz_size
-                return [200, headers, asset.css_gz]
-              else
-                headers[Rack::CONTENT_LENGTH] = asset.css_size
-                return [200, headers, asset.css]
-              end
+              return [200, headers, get_content(env, headers, asset, asset_key, asset.hash[:css][:css])]
             end
           end
 
           return [404, {}, 'not found']
         # hot reloading subscription
-        elsif Isomorfeus.development? && path_info == Isomorfeus.assets_websocket_path
+        elsif Isomorfeus.development? && path_info == Isomorfeus.hmr_websocket_path
           if env['rack.upgrade?'] == :websocket
             env['rack.upgrade'] = Isomorfeus::AssetManager::ServerSocketProcessor.new
           end
@@ -166,11 +113,29 @@ module Isomorfeus
         @app.call(env)
       end
 
-      def should_gzip?(env)
-        return true if env.key?('HTTP_ACCEPT_ENCODING') && env['HTTP_ACCEPT_ENCODING'].match?(/\bgzip\b/)
-        return false if /\bno-transform\b/.match?(env[Rack::CACHE_CONTROL].to_s) || env['Content-Encoding']&.!~(/\bidentity\b/)
-        return false if @compressible_types && !(env.key?(Rack::CONTENT_TYPE) && @compressible_types.include?(env[Rack::CONTENT_TYPE][/[^;]*/]))
-        true
+      def get_content(env, headers, asset, asset_key, content_hash)
+        request = Rack::Request.new(env)
+        best_encoding = Rack::Utils.select_best_encoding(C_ENCODINGS, request.accept_encoding)
+        content = ''
+        case best_encoding
+        when 'gzip'
+          headers['Content-Encoding'] = "gzip"
+          unless content_hash.key?(:gzip)
+            asset.mutex.synchronize { content_hash[:gzip] = Zlib::gzip(content_hash[:raw], level: Zlib::BEST_COMPRESSION) unless content_hash.key?(:gzip) }
+          end
+          content = content_hash[:gzip]
+        when 'br'
+          headers['Content-Encoding'] = "br"
+          unless content_hash.key?(:br)
+            asset.mutex.synchronize { content_hash[:br] = Brotli.deflate(content_hash[:raw], quality: Isomorfeus.production? ? 9 : 5) unless content_hash.key?(:br) }
+          end
+          content = content_hash[:br]
+        else
+          content = content_hash[:raw]
+        end
+        headers[Rack::CONTENT_LENGTH] = content.size
+        headers['Last-Modified'] = asset.mtime
+        content
       end
     end
   end

data/lib/isomorfeus/asset_manager/ruby_import.rb

@@ -13,12 +13,12 @@ module Isomorfeus
         @resolved_path ||= resolve_path
       end
 
-      def to_s
-        "import(\"./#{@module_name}.rb.js\");\n"
+      def to_s(asset_name)
+        "import(\"./#{asset_name}/#{@module_name}.rb.js\");\n"
       end
 
       def to_dev_s(asset_name)
-        "import(\"#{Isomorfeus.assets_path}/#{asset_name}/#{@module_name}.rb.js\");\n"
+        "await import(\"#{Isomorfeus.assets_path}/#{asset_name}/#{@module_name}.rb.js\");\n"
       end
 
       private

data/lib/isomorfeus/asset_manager/version.rb

@@ -1,5 +1,5 @@
 module Isomorfeus
   class AssetManager
-    VERSION = '0.14.11'
+    VERSION = '0.14.15'
   end
 end