condenser 1.4 → 1.5.1

data/test/preprocessor/js_analyzer_test.rb

@@ -7,6 +7,56 @@ class JSAnalyzerTest < ActiveSupport::TestCase
     @env.unregister_minifier('application/javascript')
   end
   
+  test 'file with exports gets marked as module and exports as module' do
+    @env.clear_pipeline
+    @env.register_preprocessor 'application/javascript', Condenser::JSAnalyzer
+    
+    file 'export.js', <<~JS
+      var t = { 'var': () => { return 2; } };
+
+      export {t as name1};
+    JS
+
+    asset = assert_file 'export.js', 'application/javascript', <<~FILE
+      var t = { 'var': () => { return 2; } };
+
+      export {t as name1};
+    FILE
+    assert_equal "module", asset.type
+        
+    asset = assert_exported_file 'export.js', 'application/javascript', <<~FILE
+      var t = { 'var': () => { return 2; } };
+
+      export {t as name1};
+    FILE
+    assert_equal "module", asset.type
+  end
+
+  test 'file with imports gets marked as module and exports as module' do
+    @env.clear_pipeline
+    @env.register_preprocessor 'application/javascript', Condenser::JSAnalyzer
+    
+    file 'import.js', <<~JS
+      import name1 from 'export'
+
+      name1();
+    JS
+
+    asset = assert_file 'import.js', 'application/javascript', <<~FILE
+      import name1 from 'export'
+
+      name1();
+    FILE
+    assert_equal "module", asset.type
+        
+    asset = assert_exported_file 'import.js', 'application/javascript', <<~FILE
+      import name1 from 'export'
+
+      name1();
+    FILE
+    assert_equal "module", asset.type
+  end
+
   test 'file with a single export' do
     file 'name.js', <<~JS
     var t = { 'var': () => { return 2; } };
@@ -49,7 +99,7 @@ class JSAnalyzerTest < ActiveSupport::TestCase
       ')': '&#41;',
     };
 
-    var resc = /[<>&\(\)\[\]"']/g;
+    var resc = /[<>&\(\)\\[\\]"']/g;
 
     JS
 
@@ -97,16 +147,16 @@ class JSAnalyzerTest < ActiveSupport::TestCase
     asset = @env.find('name.js')
     assert_nil asset.exports
     assert_equal [
+        "module-name/path/to/specific/un-exported/file6.js",
         "module-name1.js",
+        "module-name10.js",
         "module-name2.js",
         "module-name3.js",
         "module-name4.js",
         "module-name5.js",
-        "module-name/path/to/specific/un-exported/file6.js",
         "module-name7.js",
         "module-name8.js",
-        "module-name9.js",
-        "module-name10.js"
+        "module-name9.js"
       ], asset.export_dependencies.map(&:filename)
   end
 
@@ -279,8 +329,127 @@ class JSAnalyzerTest < ActiveSupport::TestCase
           }
       };
     JS
-    
+  end
+
+  test 'regex chars that dont need escaping' do
+    file 'a.js', 'this._agsAdmin=/(https?:\/\/[^/]+\/[^/]+)\/admin\/?(\/.*)?$/i'
+    asset = assert_file 'a.js', 'application/javascript'
+
+    file 'b.js', 'function T(e){return e.replaceAll(/[|\\{}()[\]^$+*?.]/g,"\\$&")}'
+    asset = assert_file 'b.js', 'application/javascript'
+
+    file 'c.js', 'f=/(?:LENGTH)?UNIT\[([^\]]+)]]$/i'
+    asset = assert_file 'c.js', 'application/javascript'
+
+    file 'd.js', 'function o(t,e){return t.replaceAll(/([.$?*|{}()[\]\\\\/+\-^])/g,(t=>e?.includes(t)?t:`\\${t}`))}'
+    asset = assert_file 'd.js', 'application/javascript'
+  end
+
+  test 'a regex after a function call or for loop' do
+    file 't.js', <<~JS
+      for(const s in r)/^(request|service)$/i.test(s)&&delete r[s];
+    JS
+
     asset = assert_file 't.js', 'application/javascript'
+    file 'b.js', <<~JS
+      e=>Math.round(1e4*e)/1e4;
+    JS
+
+    asset = assert_file 'b.js', 'application/javascript'
+    file 'c.js', <<~JS
+      {const e=this._timings.entries,t=e.length;let s=0;for(const r of e)s+=r;r=s/t}
+    JS
+
+    asset = assert_file 'c.js', 'application/javascript'
+  end
+
+  test 'file with a single line comment in a argument list before a regex' do
+    file 'name.js', <<~JS
+      function javascript(hljs) {
+
+        regex.either(
+          // Float32Array, OutT
+          /\b[A-Z][a-z]+([A-Z][a-z]*|\d)*/,
+          // CSSFactory, CSSFactoryT
+        )
+
+        const USE_STRICT = {
+          label: "use_strict",
+          className: 'meta',
+          relevance: 10,
+          begin: /^\s*['"]use (strict|asm)['"]/
+        };
+
+      }
+
+      module.exports = javascript;
+    JS
+
+    asset = assert_file 'name.js', 'application/javascript'
+    
+    
+    file 'name.js', <<~JS
+      class ScrollDirective {
+          constructor (scrollElement, ...args) {
+              this._promise = new Promise((resolve, reject) => {
+                  function step (now) {
+
+                      const elapsed = now - this.start
+                      // Behavior is (EaseOutCubic)[https://gizma.com/easing/#easeOutCubic]
+                      // TODO add easing options
+                      const percent = Math.min(1 - Math.pow(1 - elapsed / this.duration, 3), 1.0)
+                      scrollElement.scrollTo(this.deltaX * percent + this.startX, this.deltaY * percent + this.startY)
+                    
+                      id = window.requestAnimationFrame(step.bind(this))
+                  }
+
+              })
+          }
+    
+          setDirective (targetX, targetY, options={}) {
+              // support (targetX, options)
+              if (typeof targetY == "object") {
+                  options = targetY
+                  targetY = undefined
+              }
+              // support (options)
+              if (typeof targetX == "object") {
+                  options = targetX
+                  targetX = undefined
+              }
+              if (!options.duration) {
+                  this.duration = Math.max(Math.abs(this.deltaY) / this.speed, Math.abs(this.deltaX) / this.speed)
+                  if (options.minDuration) {
+                      this.duration = Math.max(this.duration, options.minDuration)
+                  }
+              }
+              return this
+          }
+
+      }
+    JS
+
+    asset = assert_file 'name.js', 'application/javascript'
+  end
+
+  test 'file with a keyword as start of a function name' do
+    file 'name.js', <<~JS
+      export default class Admin extends User {
+
+          static aroundActions = ['requireAdmin']
+    
+          async imports () {
+              this.display(imports, {
+                  user: this.application.session.user
+              }, { layout })
+          }
+      }
+    JS
+
+    asset = @env.find('name.js')
+    assert asset.exports
+    assert asset.has_default_export?
+    assert_empty asset.export_dependencies
   end
 
 end

data/test/processors/rollup/dynamic_import_test.rb

@@ -0,0 +1,358 @@
+require 'test_helper'
+
+class RollupDynamicImportTestTest < ActiveSupport::TestCase
+  
+  def setup
+    super
+    @env.unregister_minifier('application/javascript')
+  end
+ 
+  test 'dynamic imports get inlined' do
+    file 'main.js', <<~JS
+      cube = await import('./math/math');
+      bigCube = await import('math/b');
+
+      console.log( cube( 5 ) ); // 125
+    JS
+
+    file 'math/cube.js', <<~JS
+      export default function cube ( x ) {
+        return x * x * x;
+      }
+    JS
+    file 'math/math.js', <<~JS
+      import cube from './cube';
+
+      export {cube};
+    JS
+    file 'math/b.js', <<~JS
+      import cube from './cube';
+      let b = x;
+      export {cube};
+    JS
+
+    assert_exported_file 'main.js', 'application/javascript', <<~FILE
+      function cube$1 ( x ) {
+        return x * x * x;
+      }
+
+      const math = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+        __proto__: null,
+        cube: cube$1
+      }, Symbol.toStringTag, { value: 'Module' }));
+
+      x;
+
+      const b = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+        __proto__: null,
+        cube: cube$1
+      }, Symbol.toStringTag, { value: 'Module' }));
+
+      cube = await Promise.resolve().then(() => math);
+      bigCube = await Promise.resolve().then(() => b);
+
+      console.log( cube( 5 ) ); // 125
+    FILE
+  end
+
+  test 'file with dynamic imports' do
+    1.upto(3) do |i|
+      if i == 3
+        file "module-name/path/to/specific/un-exported/file#{i}.js", "#{i}"
+      else
+        file "module-name#{i}.js", "#{i}"
+      end
+    end
+
+    file 'name.js', <<~JS
+      let x = await import("module-name1");
+      let y = import("module-name2");
+      import("module-name/path/to/specific/un-exported/file3");
+    JS
+
+    asset = @env.find('name.js')
+    assert_nil asset.exports
+    assert_equal [
+      "module-name1.js",
+      "module-name2.js",
+      "module-name/path/to/specific/un-exported/file3.js"
+    ], asset.linked_assets.map(&:filename)
+  end
+
+  test "dynamic imports don't inlined and are exported" do
+    @env.unregister_exporter 'application/javascript'
+    @env.register_exporter 'application/javascript', Condenser::RollupProcessor.new(@env.npm_path, dynamic_imports: false)
+
+    file 'main.js', <<~JS
+      cube = await import('./math/math');
+      bigCube = await import('math/b');
+
+      console.log( cube( 5 ) ); // 125
+    JS
+
+    file 'math/cube.js', <<~JS
+      export default function cube ( x ) {
+        return x * x * x;
+      }
+    JS
+    file 'math/math.js', <<~JS
+      import cube from './cube';
+
+      export {cube};
+    JS
+    file 'math/b.js', <<~JS
+      import cube from './cube';
+      let b = x;
+      export {cube};
+    JS
+
+    assert_exported_file 'main.js', 'application/javascript', <<~FILE
+      cube = await import('/#{@env.find('math/math').path}');
+      bigCube = await import('/#{@env.find('math/b').path}');
+
+      console.log( cube( 5 ) ); // 125
+    FILE
+
+    Dir.mktmpdir do |export_dir|
+      manifest = Condenser::Manifest.new(@env, File.join(export_dir, 'manifest.json'))
+      main = @env['main.js']
+      math = @env['math/math.js']
+      mathb = @env['math/b.js']
+      assets = [main, math, mathb]
+
+      assets.each do |asset|
+        assert !File.exist?("#{export_dir}/#{asset.path}")
+      end
+
+      manifest.compile('main.js')
+      assert File.directory?(manifest.dir)
+      assert File.file?(manifest.filename)
+      assert File.exist?("#{export_dir}/manifest.json")
+
+      assets.each do |asset|
+        assert File.exist?("#{export_dir}/#{asset.path}")
+        assert File.exist?("#{export_dir}/#{asset.path}.gz")
+      end
+
+      data = JSON.parse(File.read(manifest.filename))
+
+      assert data['main.js']
+      assert_equal 240, data['main.js']['size']
+      assert_equal main.path, data['main.js']['path']
+      assert_equal(<<~JS.rstrip, File.read(File.join(export_dir, data['main.js']['path'])).rstrip)
+        cube = await import('/#{math.path}');
+        bigCube = await import('/#{mathb.path}');
+
+        console.log( cube( 5 ) ); // 125
+      JS
+
+      assert data['math/math.js']
+      assert_equal 62, data['math/math.js']['size']
+      assert_equal math.path, data['math/math.js']['path']
+      assert_equal(<<~JS.rstrip, File.read(File.join(export_dir, data['math/math.js']['path'])).rstrip)
+        function cube ( x ) {
+          return x * x * x;
+        }
+
+        export { cube };
+      JS
+
+      assert data['math/b.js']
+      assert_equal 66, data['math/b.js']['size']
+      assert_equal mathb.path, data['math/b.js']['path']
+      assert_equal(<<~JS.rstrip, File.read(File.join(export_dir, data['math/b.js']['path'])).rstrip)
+        function cube ( x ) {
+          return x * x * x;
+        }
+
+        x;
+
+        export { cube };
+      JS
+    end
+  end
+
+  test "dynamic imports with a prefix" do
+    @env.unregister_exporter 'application/javascript'
+    @env.register_exporter 'application/javascript', Condenser::RollupProcessor.new(@env.npm_path, prefix: "/assets", dynamic_imports: false)
+
+    file 'main.js', <<~JS
+      cube = await import('./math/math');
+      bigCube = await import('math/b');
+
+      console.log( cube( 5 ) ); // 125
+    JS
+
+    file 'math/cube.js', <<~JS
+      export default function cube ( x ) {
+        return x * x * x;
+      }
+    JS
+    file 'math/math.js', <<~JS
+      import cube from './cube';
+
+      export {cube};
+    JS
+    file 'math/b.js', <<~JS
+      import cube from './cube';
+      let b = x;
+      export {cube};
+    JS
+
+    assert_exported_file 'main.js', 'application/javascript', <<~FILE
+      cube = await import('/assets/#{@env.find('math/math').path}');
+      bigCube = await import('/assets/#{@env.find('math/b').path}');
+
+      console.log( cube( 5 ) ); // 125
+    FILE
+
+    Dir.mktmpdir do |export_dir|
+      manifest = Condenser::Manifest.new(@env, File.join(export_dir, 'manifest.json'))
+      main = @env['main.js']
+      math = @env['math/math.js']
+      mathb = @env['math/b.js']
+      assets = [main, math, mathb]
+
+      assets.each do |asset|
+        assert !File.exist?("#{export_dir}/#{asset.path}")
+      end
+
+      manifest.compile('main.js')
+      assert File.directory?(manifest.dir)
+      assert File.file?(manifest.filename)
+      assert File.exist?("#{export_dir}/manifest.json")
+
+      assets.each do |asset|
+        assert File.exist?("#{export_dir}/#{asset.path}")
+        assert File.exist?("#{export_dir}/#{asset.path}.gz")
+      end
+
+      data = JSON.parse(File.read(manifest.filename))
+
+      assert data['main.js']
+      assert_equal 254, data['main.js']['size']
+      assert_equal main.path, data['main.js']['path']
+      assert_equal(<<~JS.rstrip, File.read(File.join(export_dir, data['main.js']['path'])).rstrip)
+        cube = await import('/assets/#{math.path}');
+        bigCube = await import('/assets/#{mathb.path}');
+
+        console.log( cube( 5 ) ); // 125
+      JS
+
+      assert data['math/math.js']
+      assert_equal 62, data['math/math.js']['size']
+      assert_equal math.path, data['math/math.js']['path']
+      assert_equal(<<~JS.rstrip, File.read(File.join(export_dir, data['math/math.js']['path'])).rstrip)
+        function cube ( x ) {
+          return x * x * x;
+        }
+
+        export { cube };
+      JS
+
+      assert data['math/b.js']
+      assert_equal 66, data['math/b.js']['size']
+      assert_equal mathb.path, data['math/b.js']['path']
+      assert_equal(<<~JS.rstrip, File.read(File.join(export_dir, data['math/b.js']['path'])).rstrip)
+        function cube ( x ) {
+          return x * x * x;
+        }
+
+        x;
+
+        export { cube };
+      JS
+    end
+  end
+
+  test "cyclical dynamic imports don't inlined and are exported" do
+    @env.unregister_exporter 'application/javascript'
+    @env.register_exporter 'application/javascript', Condenser::RollupProcessor.new(@env.npm_path, dynamic_imports: false)
+
+    file 'main.js', <<~JS
+      const cube = await import('./math/math');
+
+      console.log( cube( 5 ) ); // 125
+    JS
+
+    file 'math/cube.js', <<~JS
+      const math = await import('./math');
+
+      export default function cube ( x ) {
+        return math.number(x) * x * x;
+      }
+    JS
+    file 'math/math.js', <<~JS
+      import cube from './cube';
+
+      function number (x) { return x; }
+
+      export {cube, number};
+    JS
+
+    assert_exported_file 'main.js', 'application/javascript', <<~FILE
+      const cube = await import('/#{@env.find('/math/math').export.path}');
+
+      console.log( cube( 5 ) ); // 125
+    FILE
+
+    Dir.mktmpdir do |export_dir|
+      manifest = Condenser::Manifest.new(@env, File.join(export_dir, 'manifest.json'))
+      main = @env['main.js']
+      math = @env['math/math.js']
+      cube = @env['math/cube.js']
+      assets = [main, math]
+
+      assets.each do |asset|
+        assert !File.exist?("#{export_dir}/#{asset.path}")
+      end
+
+      manifest.compile('main.js')
+      assert File.directory?(manifest.dir)
+      assert File.file?(manifest.filename)
+      assert File.exist?("#{export_dir}/manifest.json")
+
+      assets.each do |asset|
+        assert File.exist?("#{export_dir}/#{asset.path}")
+        assert File.exist?("#{export_dir}/#{asset.path}.gz")
+      end
+
+      data = JSON.parse(File.read(manifest.filename))
+
+      assert_equal ["main.js", "math/math.js"], data.keys
+
+      assert data['main.js']
+      assert_equal 143, data['main.js']['size']
+      assert_equal main.path, data['main.js']['path']
+      assert_equal(<<~JS.rstrip, File.read(File.join(export_dir, data['main.js']['path'])).rstrip)
+        const cube = await import('/#{math.path}');
+
+        console.log( cube( 5 ) ); // 125
+      JS
+
+      assert data['math/math.js']
+      assert_equal 336, data['math/math.js']['size']
+      assert_equal math.path, data['math/math.js']['path']
+      assert_equal(<<~JS.rstrip, File.read(File.join(export_dir, data['math/math.js']['path'])).rstrip)
+        const math = await Promise.resolve().then(() => entry);
+
+        function cube ( x ) {
+          return math.number(x) * x * x;
+        }
+
+        function number (x) { return x; }
+
+        const entry = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+          __proto__: null,
+          cube,
+          number
+        }, Symbol.toStringTag, { value: 'Module' }));
+
+        export { cube, number };
+      JS
+    end
+  end
+
+  #TODO: add test for inilne / not inline URLs
+
+end