condenser 1.2 → 1.4

data/lib/condenser/processors/rollup_processor.rb

@@ -7,7 +7,7 @@ class Condenser::RollupProcessor < Condenser::NodeProcessor
   
   def initialize(dir = nil, options = {})
     super(dir)
-    npm_install('rollup', 'rollup-plugin-commonjs', 'rollup-plugin-node-resolve')
+    npm_install('rollup', '@rollup/plugin-commonjs', '@rollup/plugin-node-resolve')
     
     @options = options.freeze
   end
@@ -50,7 +50,12 @@ class Condenser::RollupProcessor < Condenser::NodeProcessor
             return '';
           } catch(e) {
             if (e.name === "SyntaxError") {
-              if (e.message.startsWith('Unexpected token { in JSON at position ')) {
+              if (e.message.startsWith('Unexpected non-whitespace character after JSON at position ')) {
+                var pos = parseInt(e.message.slice(59));
+                emitMessages(buffer.slice(0,pos));
+                return emitMessages(buffer.slice(pos));
+              } else if (e.message.startsWith('Unexpected token { in JSON at position ')) {
+                // This can be removed, once dropping support for node <= v18
                 var pos = parseInt(e.message.slice(39));
                 emitMessages(buffer.slice(0,pos));
                 return emitMessages(buffer.slice(pos));
@@ -70,8 +75,8 @@ class Condenser::RollupProcessor < Condenser::NodeProcessor
         });
         
         const rollup = require("#{npm_module_path('rollup')}");
-        const commonjs = require("#{npm_module_path('rollup-plugin-commonjs')}");
-        const nodeResolve = require("#{npm_module_path('rollup-plugin-node-resolve')}");
+        const commonjs = require("#{npm_module_path('@rollup/plugin-commonjs')}");
+        const nodeResolve = require("#{npm_module_path('@rollup/plugin-node-resolve')}").nodeResolve;
         var rid = 0;
         var renderStack = {};
         var nodeResolver = null;
@@ -95,9 +100,8 @@ class Condenser::RollupProcessor < Condenser::NodeProcessor
             mainFields: ['module', 'main'],
             // modulesOnly: true,
             // preferBuiltins: false,
-            customResolveOptions: {
-              moduleDirectory: '#{npm_module_path}'
-            }
+            moduleDirectories: [],
+            modulePaths: ['#{npm_module_path}']
           });
         }
 
@@ -105,9 +109,9 @@ class Condenser::RollupProcessor < Condenser::NodeProcessor
         inputOptions.plugins = [];
         inputOptions.plugins.push({
           name: 'condenser',
-          resolveId: function (importee, importer) {
+          resolveId: function (importee, importer, options) {
             if (importee.startsWith('\\0') || (importer && importer.startsWith('\\0'))) {
-              return;
+              return null;
             }
 
             if (!(importer in renderStack)) {
@@ -115,24 +119,15 @@ class Condenser::RollupProcessor < Condenser::NodeProcessor
             }
 
             return request('resolve', [importee, importer]).then((value) => {
-              if (nodeResolver && (value === null || value === undefined)) {
-                return nodeResolver.resolveId.call(this, importee, importer).then((value) => {
-                  if (!(value === null || value === undefined) && !renderStack[importer].includes(value.id)) {
-                    renderStack[importer].push(value.id);
-                  }
-                  return value;
-                });
-              }
-
-              if (!(value === null || value === undefined) && !renderStack[importer].includes(value)) {
-                renderStack[importer].push(value);
-              }
-              return value;
+                if (!(value === null || value === undefined) && !renderStack[importer].includes(value)) {
+                  renderStack[importer].push(value);
+                }
+                return value;
             });
           },
           load: function(id) {
             if (id.startsWith('\\0')) {
-              return;
+              return null;
             }
 
             return request('load', [id]).then(function(value) {
@@ -140,17 +135,19 @@ class Condenser::RollupProcessor < Condenser::NodeProcessor
             });
           }
         });
+        
         inputOptions.plugins.push(nodeResolver);
         inputOptions.plugins.push(commonjs());
         
-        inputOptions.plugins.push({
-          name: 'nullHanlder',
-          resolveId: function (importee, importer) {
-            request('error', ["AssetNotFound", importee, importer, renderStack]).then(function(value) {
-              process.exit(1);
-            });
-          }
-        });
+        // inputOptions.plugins.push({
+        //   name: 'nullHanlder',
+        //   resolveId: function (importee, importer, options) {
+        //     request('log', [importee, importer, options])
+        //     // request('error', ["AssetNotFound", importee, importer, renderStack]).then(function(value) {
+        //     //   process.exit(1);
+        //     // });
+        //   }
+        // });
 
         const outputOptions = #{JSON.generate(output_options)};
 
@@ -204,14 +201,20 @@ class Condenser::RollupProcessor < Condenser::NodeProcessor
               @entry
             elsif importee.start_with?('@babel/runtime') || importee.start_with?('core-js-pure') || importee.start_with?('regenerator-runtime')
               x = File.join(npm_module_path, importee.gsub(/^\.\//, File.dirname(importer) + '/')).sub('/node_modules/regenerator-runtime', '/node_modules/regenerator-runtime/runtime.js')
-              x = "#{x}.js" if !x.end_with?('.js')
+              x = "#{x}.js" if !x.end_with?('.js', '.mjs')
+              File.file?(x) ? x : (x.delete_suffix('.js') + "/index.js")
+            elsif npm_module_path && importee&.start_with?(npm_module_path)
+              x = importee.end_with?('.js', '.mjs') ? importee : "#{importee}.js"
+              x = (x.delete_suffix('.js') + "/index.js") if !File.file?(x)
+              x
+            elsif importee.start_with?('.') && importer.start_with?(npm_module_path)
+              x = File.expand_path(importee, File.dirname(importer))
+              x = "#{x}.js" if !x.end_with?('.js', '.mjs')
               File.file?(x) ? x : (x.delete_suffix('.js') + "/index.js")
-            elsif npm_module_path && importer.start_with?(npm_module_path)
-              nil
             elsif importee.end_with?('*')
               File.join(File.dirname(importee), '*')
             else
-              @environment.find(importee, importer ? File.dirname(@entry == importer ? @input[:source_file] : importer) : nil, accept: @input[:content_types].last)&.source_file
+              @environment.find(importee, importer ? (@entry == importer ? @input[:source_file] : importer) : nil, accept: @input[:content_types].last)&.source_file
             end
           when 'load'
             importee = message['args'].first
@@ -261,7 +264,6 @@ class Condenser::RollupProcessor < Condenser::NodeProcessor
           # when 'get_cache'
           #   io.write(JSON.generate({rid: message['rid'], return: [(@environment.cache.get('rollup') || '{}')] }))
           end
-
           io.write(JSON.generate({rid: message['rid'], return: ret}))
         end
       end

data/lib/condenser/resolve.rb

@@ -38,9 +38,7 @@ class Condenser
           end
         
           paths.each do |path|
-            glob = path
-            glob = File.join(glob, dirname) if dirname
-            glob = File.join(glob, basename)
+            glob = File.join(*[path, dirname, basename].compact)
             glob << '.*' unless glob.end_with?('*')
           
             Dir.glob(glob).sort.each do |f|
@@ -150,11 +148,34 @@ class Condenser
       end
     end
     
+    def has_dir?(path)
+      path.count('/') > (path.start_with?('/') ? 1 : 0)
+    end
+    
+    def expand_path(path)
+      dir = if path.start_with?('/')
+        File.expand_path(path)
+      else
+        File.expand_path("/#{path}").delete_prefix('/')
+      end
+      dir.empty? ? nil : dir
+    end
+    
     def decompose_path(path, base=nil)
-      dirname = path.index('/') ? File.dirname(path) : nil
-      if base && path&.start_with?('.')
-        dirname = File.expand_path(dirname, base)
+      dirname = if base && path.start_with?('.')
+        if has_dir?(base)
+          if has_dir?(path)
+            expand_path(File.join(File.dirname(base), File.dirname(path)))
+          else
+            expand_path(File.dirname(base))
+          end
+        else
+          expand_path(File.dirname(path))
+        end
+      else
+        path.index('/') ? File.dirname(path) : nil
       end
+
       
       _, star, basename, extensions = path.match(/(([^\.\/]+)(\.[^\/]+)|\*|[^\/]+)$/).to_a
       if extensions == '.*'

data/lib/condenser/templating_engine/ejs.rb

@@ -1,4 +1,4 @@
-class Condenser::EjsTemplare
+class Condenser::EjsTemplate
 
   def self.setup(environment)
     require 'ejs' unless defined?(::EJS)

data/lib/condenser/transformers/dart_sass_transformer.rb

@@ -0,0 +1,285 @@
+class Condenser::DartSassTransformer < Condenser::NodeProcessor
+
+  @@helper_methods = Set.new
+  
+  ACCEPT = ['text/css', 'text/scss', 'text/sass']
+
+  attr_accessor :options
+  
+  # Use this function to append Modules that contain functions to expose
+  # to dart-sass
+  def self.add_helper_methods(module_to_add = nil, &block)
+    old_methods = self.instance_methods
+    
+    self.include(module_to_add) if module_to_add
+    self.class_eval(&block) if block_given?
+    
+    @@helper_methods.merge(self.instance_methods - old_methods)
+  end
+  
+  add_helper_methods(Condenser::Sass::Functions)
+  
+  def self.syntax
+    :sass
+  end
+  
+  def initialize(dir, options = {})
+    super(dir)
+    npm_install('sass')
+    
+    @options = options.merge({
+      indentedSyntax: self.class.syntax == :sass
+    }).freeze
+  end
+
+  def helper_method_signatures
+    x = @@helper_methods.map do |name|
+      arity = self.method(name).arity
+      signature = []
+      types = []
+      if respond_to?(:"#{name}_signature")
+        send(:"#{name}_signature").each do |arg, type|
+          signature << arg
+          types << type
+        end
+      elsif arity >= 0
+        arity.times.with_index do |a|
+          signature << "$arg#{a}"
+          types << 'String'
+        end
+      end
+      
+      ["#{name}(#{signature.join(', ')})", types]
+    end
+    x
+  end
+  
+  def call(environment, input)
+    @context = environment.new_context_class#.new(environment)
+    
+    options = {
+      verbose: true,
+      file: File.join('/', input[:filename])
+    }.merge(@options)
+    @environment = environment
+    @input = input
+
+    result = exec_runtime(<<-JS)
+      const fs    = require('fs');
+      const sass = require("#{npm_module_path('sass')}");
+      const stdin = process.stdin;
+      stdin.resume();
+      stdin.setEncoding('utf8');
+      
+      // SET STDOUT to sync so that we don't get in an infinte looping waiting
+      // for Ruby to response when we haven't even sent the entire request.
+      if (process.stdout._handle) process.stdout._handle.setBlocking(true)
+        
+      const source = #{JSON.generate(input[:source])};
+      const options = #{JSON.generate(options)};
+
+      var rid = 0;
+      function request(method, ...args) {
+        var trid = rid;
+        rid += 1;
+        console.log(JSON.stringify({ rid: trid, method: method, args: args }) + "\\n");
+        
+
+        var readBuffer = '';
+        var response = null;
+        let chunk = new Buffer(1024);
+        let bytesRead;
+        
+        while (response === null) {
+          try {
+            bytesRead = fs.readSync(stdin.fd, chunk, 0, 1024);
+            if (bytesRead === null) { exit(1); }
+            readBuffer += chunk.toString('utf8', 0, bytesRead);
+            [readBuffer, response] = readResponse(readBuffer);
+          } catch (e) {
+             if (e.code !== 'EAGAIN') { throw e; }
+          }
+        }
+        return response['return'];
+      }
+      
+      function readResponse(buffer) {
+        try {
+          var message = JSON.parse(buffer);
+          return ['', message];
+        } catch(e) {
+          if (e.name === "SyntaxError") {
+            if (e.message.startsWith('Unexpected non-whitespace character after JSON at position ')) {
+              let pos = parseInt(e.message.slice(59));
+              let [b, r] = readResponse(buffer.slice(0,pos));
+              return [b + buffer.slice(pos), r];
+            } else if (e.message.startsWith('Unexpected token { in JSON at position ')) {
+              // This can be removed, once dropping support for node <= v18
+              var pos = parseInt(e.message.slice(39));
+              let [b, r] = readResponse(buffer.slice(0,pos));
+              return [b + buffer.slice(pos), r];
+            } else {
+              return [buffer, null];
+            }
+          } else {
+            console.log(JSON.stringify({method: 'error', args: [e.name, e.message]}) + "\\n");
+            process.exit(1);
+          }
+        }
+      }
+      
+      
+      options.importer = function(url, prev) { return request('load', url, prev); };
+      
+      const call_fn = function(name, types, args) {
+        const transformedArgs = [];
+        request('log', '==================')
+        args.forEach((a, i) => {
+          if (types[i] === 'Map') {
+            // Don't know how to go from SassMap to hash yet
+            transformedArgs.push({});
+          } else if (types[i] === 'List') {
+            // Don't know how to go from SassList to hash yet
+            transformedArgs.push([]);
+          } else if (!(a instanceof sass.types[types[i]])) {
+            throw "$url: Expected a string."; 
+          } else {
+            transformedArgs.push(a.getValue());
+          }
+           
+
+          // if (types[i] === 'List') { a = a.contents(); }
+        });
+        request('log', name, transformedArgs, types)
+        return new sass.types.String(request('call', name, transformedArgs));
+      }
+      options.functions = {};
+      #{JSON.generate(helper_method_signatures)}.forEach( (f) => {
+        let name = f[0].replace(/-/g, '_').replace(/(^[^\\(]+)\\(.*\\)$/, '$1');
+        options.functions[f[0]] = (...a) => call_fn(name, f[1], a);
+      })
+      
+      try {
+        options.data = source;
+        const result = sass.renderSync(options);
+        request('result', result.css.toString());
+        process.exit(0);
+      } catch(e) {
+        request('error', e.name, e.message);
+        process.exit(1);
+      }
+    JS
+    
+    input[:source] = result
+    # input[:map] = map.to_json({})
+    input[:linked_assets]         += @context.links
+    input[:process_dependencies]  += @context.dependencies
+  end
+  
+  def find(importee, importer = nil)
+    # importer ||= @input[:source_file]
+    @environment.find(expand_path(importee, importer), nil, accept: ACCEPT)
+  end
+  
+  def resolve(importee, importer = nil)
+    # importer ||= @input[:source_file]
+    @environment.resolve(expand_path(importee, importer), accept: ACCEPT)
+  end
+  
+  def expand_path(path, base=nil)
+    if path.start_with?('.')
+      File.expand_path(path, File.dirname(base)).delete_prefix(File.expand_path('.') + '/')
+    else
+      File.expand_path(path).delete_prefix(File.expand_path('.') + '/')
+    end
+  end
+  
+  def exec_runtime(script)
+    io = IO.popen([binary, '-e', script], 'r+')
+    buffer = ''
+    result = nil
+    
+    begin
+      while IO.select([io]) && io_read = io.read_nonblock(1_024)
+        buffer << io_read
+        messages = buffer.split("\n\n")
+        buffer = buffer.end_with?("\n\n") ? '' : messages.pop
+        
+        messages.each do |message|
+          message = JSON.parse(message)
+
+          ret = case message['method']
+          when 'result'
+            result = message['args'][0]
+            nil
+          when 'load'
+            importee = message['args'][0]
+            importer = message['args'][1]
+            
+            if importee.end_with?('*')
+              @context.depend_on(importee)
+              code = ""
+              resolve(importee, importer).each do |f, i|
+                code << "@import '#{f.filename}';\n"
+              end
+              { contents: code, map: nil }
+            else
+              if asset = find(importee)
+                @context.depend_on(asset.filename)
+                { contents: asset.source, map: asset.sourcemap }
+              else
+                @context.depend_on(importee)
+                nil
+              end
+            end
+          when 'error'
+            io.write(JSON.generate({rid: message['rid'], return: nil}))
+            
+            case message['args'][0]
+            when 'AssetNotFound'
+              error_message = "Could not find import \"#{message['args'][1]}\" for \"#{message['args'][2]}\".\n\n"
+              error_message << build_tree(message['args'][3], input, message['args'][2])
+              raise exec_runtime_error(error_message)
+            else
+              raise exec_runtime_error(message['args'][0] + ': ' + message['args'][1])
+            end
+          when 'call'
+            if respond_to?(message['args'][0])
+              send(message['args'][0], *message['args'][1])
+            else
+              puts '!!!'
+            end
+          end
+
+          io.write(JSON.generate({rid: message['rid'], return: ret}))
+        end
+      end
+    rescue Errno::EPIPE, EOFError
+    end
+    
+    io.close
+    if $?.success?
+      result
+    else
+      raise exec_runtime_error(buffer)
+    end
+  end
+  
+  protected
+
+  def condenser_context
+    @context
+  end
+  
+  def condenser_environment
+    @environment
+  end
+
+  
+end
+
+class Condenser::DartScssTransformer < Condenser::DartSassTransformer
+  def self.syntax
+    :scss
+  end
+end

data/lib/condenser/transformers/jst_transformer.rb

@@ -23,32 +23,32 @@ class Condenser::JstTransformer < Condenser::NodeProcessor
       const source = #{JSON.generate(input[:source])};
       const options = #{JSON.generate(opts).gsub(/"@?babel[\/-][^"]+"/) { |m| "require(#{m})"}};
 
-      function globalVar(scope, name) {
-        if (name in scope.globals) {
-          return true;
-        } else if (scope.parent === null || scope.parent === undefined) {
-          return false;
-        } else {
-          return globalVar(scope.parent, name);
-        }
-      }
-
+      let scope = [['document', 'window']];
+      
       options['plugins'].unshift(function({ types: t }) {
         return {
           visitor: {
             Identifier(path, state) {
-              if ( path.parent.type == 'MemberExpression' && path.parent.object != path.node) {
+              if ( path.parent.type === 'MemberExpression' && path.parent.object !== path.node) {
                 return;
               }
-              if ( path.parent.type == 'ImportSpecifier' || path.parent.type == 'ImportDefaultSpecifier' || path.parent.type =='FunctionDeclaration') {
+              
+              if ( path.parent.type === 'ImportSpecifier' ||
+                   path.parent.type === 'ImportDefaultSpecifier' ||
+                   path.parent.type === 'FunctionDeclaration' ||
+                   path.parent.type === 'FunctionExpression' ||
+                   path.parent.type === 'ArrowFunctionExpression' ||
+                   path.parent.type === 'SpreadElement' ||
+                   path.parent.type === 'CatchClause' ) {
+                return;
+              }
+              
+              if ( path.parent.type === 'ObjectProperty' && path.parent.key === path.node ) {
                 return;
               }
 
-              if (
-                path.node.name !== 'document' &&
-                path.node.name !== 'window' &&
-                !(path.node.name in global) &&
-                globalVar(path.scope, path.node.name)
+              if ( !(path.node.name in global) &&
+                   !scope.find((s) => s.find(v => v === path.node.name))
               ) {
                 path.replaceWith(
                   t.memberExpression(t.identifier("locals"), path.node)
@@ -58,6 +58,56 @@ class Condenser::JstTransformer < Condenser::NodeProcessor
           }
         };
       });
+      
+
+      options['plugins'].unshift(function({ types: t }) {
+          return {
+            visitor: {
+              "FunctionDeclaration|FunctionExpression|ArrowFunctionExpression": {
+                enter(path, state) {
+                  if (path.node.id) { scope[scope.length-1].push(path.node.id.name); }
+                  scope.push(path.node.params.map((n) => n.type === 'RestElement' ? n.argument.name : n.name));
+                }
+              },
+              CatchClause: {
+                enter(path, state) {
+                  scope.push([]);
+                  if (path.node.param.name) { scope[scope.length-1].push(path.node.param.name); }
+                }
+              },
+              Scopable: {
+                enter(path, state) {
+                  if (path.node.type !== 'Program' &&
+                      path.node.type !== 'CatchClause' &&
+                      path.parent.type !== 'FunctionDeclaration' &&
+                      path.parent.type !== 'FunctionExpression' &&
+                      path.parent.type !== 'ArrowFunctionExpression' &&
+                      path.parent.type !== 'ExportDefaultDeclaration') {
+                    scope.push([]);
+                  }
+                },
+                exit(path, state) {
+                  if (path.node.type !== 'Program' &&
+                      path.parent.type !== 'ExportDefaultDeclaration') {
+                    scope.pop();
+                  }
+                }
+              },
+              ImportDeclaration(path, state) {
+                path.node.specifiers.forEach((s) => scope[scope.length-1].push(s.local.name));
+              },
+              ClassDeclaration(path, state) {
+                if (path.node.id) {
+                  scope[scope.length-1].push(path.node.id.name)
+                }
+              },
+              VariableDeclaration(path, state) {
+                path.node.declarations.forEach((s) => scope[scope.length-1].push(s.id.name));
+              }
+            }
+          };
+      });
+
 
       try {
         const result = babel.transform(source, options);