esbuild 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 773fae0a508c3fa01fdf258941d7929f7a00db2d75a31cd717277a1c5268421f
+  data.tar.gz: 14e77b505c53e4f9e2af88e7ce868d154baaddb0387b0875d10e520daacd7c83
+SHA512:
+  metadata.gz: d1e6acf3d2b2cadecc2bbc321d88aa539e70234bf97dbda4619dca661c7832338a53c9b1d9ce971264e5c1d655f7e9bfcee3864e68ce6446f59164c8b3f2ba09
+  data.tar.gz: 07e6efd4130d489aa6f8fda5eea9fc2017bd37793ee38d4246143bd4b12bde5fac063f9d9919ea0109a0676065b25fe7b751d886728dfa914f14676d8b46b744

data/.github/workflows/main.yml

@@ -0,0 +1,24 @@
+name: Ruby
+
+on: [push,pull_request]
+
+jobs:
+  build:
+    strategy:
+      matrix:
+        os:
+          - ubuntu-latest
+          - macos-latest
+    runs-on: ${{ matrix.os }}
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: 3.0.0
+    - name: Run the default task
+      run: |
+        gem install bundler -v 2.2.15
+        bundle install
+        bundle exec rake # Install binary
+        bundle exec rake test

data/.gitignore

@@ -0,0 +1,13 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.DS_Store
+.idea
+/tmp/
+/node_modules
+/bin/esbuild

data/Gemfile

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in esbuild.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,50 @@
+PATH
+  remote: .
+  specs:
+    esbuild (0.1.0)
+      concurrent-ruby (~> 1.1.8)
+      rake (~> 13.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.2)
+    concurrent-ruby (1.1.8)
+    minitest (5.14.4)
+    parallel (1.20.1)
+    parser (3.0.0.0)
+      ast (~> 2.4.1)
+    rainbow (3.0.0)
+    rake (13.0.3)
+    regexp_parser (2.1.1)
+    rexml (3.2.4)
+    rubocop (1.11.0)
+      parallel (~> 1.10)
+      parser (>= 3.0.0.0)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml
+      rubocop-ast (>= 1.2.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 3.0)
+    rubocop-ast (1.4.1)
+      parser (>= 2.7.1.5)
+    rubocop-performance (1.10.1)
+      rubocop (>= 0.90.0, < 2.0)
+      rubocop-ast (>= 0.4.0)
+    ruby-progressbar (1.11.0)
+    standard (1.0.4)
+      rubocop (= 1.11.0)
+      rubocop-performance (= 1.10.1)
+    unicode-display_width (2.0.0)
+
+PLATFORMS
+  arm64-darwin-20
+
+DEPENDENCIES
+  esbuild!
+  minitest (~> 5.14.4)
+  standard (~> 1.0.4)
+
+BUNDLED WITH
+   2.2.15

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Bouke van der Bijl
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,27 @@
+# Esbuild
+
+Use [esbuild](https://github.com/evanw/esbuild) from Ruby.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'esbuild'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install esbuild
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/bouk/esbuild-ruby.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "bundler/gem_tasks"
+require "rake/testtask"
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.pattern = "test/**/*_test.rb"
+  t.verbose = false
+end
+
+task :download_binary do
+  require_relative "lib/esbuild/binary_installer"
+  esbuild_bin = File.join(__dir__, "bin", "esbuild")
+  installer = Esbuild::BinaryInstaller.new(RUBY_PLATFORM, esbuild_bin)
+  installer.install
+end
+
+task default: :download_binary

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "esbuild"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/esbuild.gemspec

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "lib/esbuild/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "esbuild"
+  spec.version = Esbuild::VERSION
+  spec.authors = ["Bouke van der Bijl"]
+  spec.email = ["i@bou.ke"]
+
+  spec.summary = "Use esbuild from Ruby"
+  spec.homepage = "https://github.com/bouk/esbuild-ruby"
+  spec.license = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.4.0")
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  spec.extensions = ["Rakefile"]
+  spec.add_dependency "concurrent-ruby", "~> 1.1.8"
+  spec.add_development_dependency "minitest", "~> 5.14.4"
+  spec.add_development_dependency "standard", "~> 1.0.4"
+  spec.add_dependency "rake", "~> 13.0"
+end

data/lib/esbuild.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "esbuild/version"
+require_relative "esbuild/packet"
+require_relative "esbuild/stdio_protocol"
+require_relative "esbuild/service"
+
+module Esbuild
+  class << self
+    def build(options)
+      service.build_or_serve(options)
+    end
+
+    def serve(serve_options, build_options)
+      service.build_or_serve(build_options, serve_options)
+    end
+
+    def transform(input, options = {})
+      service.transform(input, options)
+    end
+
+    private
+
+    def service
+      @service ||= Service.new
+    end
+  end
+end

data/lib/esbuild/binary_installer.rb

@@ -0,0 +1,65 @@
+require_relative "version"
+require "fileutils"
+require "open3"
+require "net/https"
+
+module Esbuild
+  class BinaryInstaller
+    attr_reader :platform, :path
+    def initialize(platform, path)
+      package = package_from_platform(platform)
+      raise ArgumentError, "Unknown platform #{platform}" unless package
+      @package = package
+      @path = path
+    end
+
+    def install
+      tempfile = "#{@path}__"
+      if ENV["ESBUILD_BINARY_PATH"]
+        FileUtils.cp(ENV["ESBUILD_BINARY_PATH"], tempfile)
+      else
+        # TODO: use cache
+        download(tempfile)
+      end
+
+      validate_binary_version!(tempfile)
+      FileUtils.mv(tempfile, @path)
+    end
+
+    private
+
+    def download(target)
+      url = "https://unpkg.com/#{@package}@#{ESBUILD_VERSION}/bin/esbuild"
+      warn "Downloading esbuild binary from #{url}"
+
+      uri = URI(url)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      http.start do
+        request = Net::HTTP::Get.new uri
+        http.request(request) do |response|
+          File.open(target, "wb", 0o755) do |f|
+            response.read_body(f)
+          end
+        end
+      end
+    end
+
+    def validate_binary_version!(path)
+      version, _ = Open3.capture2(path, "--version")
+      version = version.strip
+      raise "Expected #{ESBUILD_VERSION} but got #{version}" unless ESBUILD_VERSION == version
+    end
+
+    def package_from_platform(platform)
+      case platform
+      when /^x86_64-darwin/
+        "esbuild-darwin-64"
+      when /^arm64-darwin/
+        "esbuild-darwin-arm64"
+      when "x86_64-linux"
+        "esbuild-linux-64"
+      end
+    end
+  end
+end

data/lib/esbuild/build_result.rb

@@ -0,0 +1,70 @@
+require "forwardable"
+require "json"
+
+module Esbuild
+  class BuildResult
+    extend Forwardable
+
+    class OutputFile
+      attr_reader :path
+      attr_reader :contents
+
+      def initialize(path, contents)
+        @path = path
+        @contents = contents
+      end
+
+      def text
+        @text ||= contents.dup.force_encoding(Encoding::UTF_8)
+      end
+    end
+
+    class Metafile
+      class Input < Struct.new(:bytes, :imports)
+        def initialize(hash)
+          super(hash["bytes"], hash["imports"])
+        end
+      end
+
+      class Output < Struct.new(:imports, :exports, :entry_point, :inputs)
+        class Input < Struct.new(:bytes_in_output)
+          def initialize(hash)
+            super(hash["bytesInOutput"])
+          end
+        end
+
+        def initialize(hash)
+          inputs = hash["inputs"].transform_values! { |v| Input.new(v) }
+          super(hash["imports"], hash["exports"], hash["entryPoint"], inputs)
+        end
+      end
+
+      attr_reader :inputs
+      attr_reader :outputs
+
+      def initialize(json)
+        hash = JSON.parse(json)
+        @inputs = hash["inputs"].transform_values! { |v| Input.new(v) }
+        @outputs = hash["outputs"].transform_values! { |v| Output.new(v) }
+      end
+    end
+
+    attr_reader :warnings
+    attr_reader :output_files
+    attr_reader :metafile
+    def_delegators :@state, :stop, :rebuild, :dispose
+
+    def initialize(response, state)
+      @state = state
+      @warnings = response["warnings"] # TODO: symbolize keys
+
+      if response["outputFiles"]
+        @output_files = response["outputFiles"].map { |f| OutputFile.new(f["path"], f["contents"]) }
+      end
+
+      if response["metafile"]
+        @metafile = Metafile.new(response["metafile"])
+      end
+    end
+  end
+end

data/lib/esbuild/build_state.rb

@@ -0,0 +1,66 @@
+module Esbuild
+  class BuildState
+    def initialize(service, on_rebuild)
+      @service = service
+      @rebuild_id = nil
+      @watch_id = nil
+      @on_rebuild = on_rebuild
+    end
+
+    def stop
+      return unless @watch_id
+      @service.stop_watch(@watch_id)
+      @watch_id = nil
+    end
+
+    def dispose
+      return unless @rebuild_id
+      res = @service.send_request("command" => "rebuild-dispose", "rebuildID" => @rebuild_id)
+      @rebuild_id = nil
+      res
+    end
+
+    def rebuild
+      raise "Cannot rebuild" if @rebuild_id.nil?
+      rebuild_response = @service.send_request("command" => "rebuild", "rebuildID" => @rebuild_id)
+      response_to_result(rebuild_response)
+    end
+
+    def handle_watch(error, response)
+      return @on_rebuild.call(error, nil) if error
+      unless response["errors"].empty?
+        error = BuildFailureError.new(response["errors"], response["warnings"])
+        @on_rebuild.call(error, nil)
+        return
+      end
+
+      result = BuildResult.new(response, self)
+      @on_rebuild.call(nil, result)
+    end
+
+    def response_to_result(res)
+      unless res["errors"].empty?
+        raise BuildFailureError, res["errors"], res["warnings"]
+      end
+      if res["writeToStdout"]
+        $stdout.puts res["writeToStdout"].rstrip
+      end
+
+      result = BuildResult.new(res, self)
+
+      # Handle incremental rebuilds
+      if res["rebuildID"] && !@rebuild_id
+        @rebuild_id = res["rebuildID"]
+      end
+
+      # Handle watch mode
+      if res["watchID"] && !@watch_id
+        @watch_id = res["watchID"]
+        if @on_rebuild
+          @service.start_watch(@watch_id, ->(error, watch_response) { handle_watch(error, watch_response) })
+        end
+      end
+      result
+    end
+  end
+end

data/lib/esbuild/flags.rb

@@ -0,0 +1,218 @@
+module Esbuild
+  module Flags
+    extend self
+
+    class OneOf
+      def initialize(*classes)
+        @classes = classes
+      end
+
+      def ===(other)
+        @classes.any? { |klass| klass === other }
+      end
+
+      def to_s
+        @classes.join(" or ")
+      end
+
+      def self.[](*classes)
+        new(*classes)
+      end
+    end
+
+    BOOL = OneOf[true, false]
+    STRING_OR_ARRAY = OneOf[String, Array]
+    STRING_OR_OBJECT = OneOf[String, Hash]
+    BOOL_OR_OBJECT = OneOf[BOOL, Hash]
+    STRING_OR_BOOL = OneOf[String, BOOL]
+    STRING_OR_SYMBOL = OneOf[String, Symbol]
+    ARRAY_OR_OBJECT = OneOf[Array, Hash]
+
+    def flags_for_transform_options(options)
+      flags = []
+      options = options.dup
+      push_log_flags(flags, options, :silent)
+      push_common_flags(flags, options)
+      get_flag(options, :source_map, STRING_OR_BOOL) { |v| flags << "--source-map=#{v == true ? "external" : v}" if v }
+      get_flag(options, :tsconfig_raw, STRING_OR_OBJECT) { |v| flags << "--tsconfig-raw=#{v.is_a?(String) ? v : JSON.dump(v)}" }
+      get_flag(options, :source_file, String) { |v| flags << "--sourcefile=#{v}" }
+      get_flag(options, :loader, STRING_OR_SYMBOL) { |v| flags << "--loader=#{v}" }
+      get_flag(options, :banner, String) { |v| flags << "--banner=#{v}" }
+      get_flag(options, :footer, String) { |v| flags << "--footer=#{v}" }
+      raise ArgumentError, "Invalid option in transform() call: #{options.keys.first}" unless options.empty?
+      flags
+    end
+
+    def flags_for_build_options(options)
+      flags = []
+      options = options.dup
+      push_log_flags(flags, options, :info)
+      push_common_flags(flags, options)
+      get_flag(options, :source_map, STRING_OR_BOOL) { |v| flags << "--source-map#{v == true ? "" : "=#{v}"}" if v }
+      get_flag(options, :bundle, BOOL) { |v| flags << "--bundle" if v }
+      watch_mode = nil
+      get_flag(options, :watch, BOOL_OR_OBJECT) do |v|
+        break unless v
+        flags << "--watch"
+        watch_mode = {}
+        unless v == true
+          watch_options = v.dup
+          get_flag(watch_options, :on_rebuild, Proc) { |v| watch_mode[:on_rebuild] = v }
+          raise ArgumentError, "Invalid option in watch options: #{watch_options.keys.first}" unless watch_options.empty?
+        end
+      end
+      get_flag(options, :splitting, BOOL) { |v| flags << "--splitting" if v }
+      get_flag(options, :preserve_symlinks, BOOL) { |v| flags << "--preserve-symlinks" if v }
+      get_flag(options, :metafile, BOOL) { |v| flags << "--metafile" if v }
+      get_flag(options, :outfile, String) { |v| flags << "--outfile=#{v}" }
+      get_flag(options, :outdir, String) { |v| flags << "--outdir=#{v}" }
+      get_flag(options, :outbase, String) { |v| flags << "--outbase=#{v}" }
+      get_flag(options, :platform, String) { |v| flags << "--platform=#{v}" }
+      get_flag(options, :tsconfig, String) { |v| flags << "--tsconfig=#{v}" }
+      get_flag(options, :resolve_extensions, Array) do |v|
+        exts = v.map do |ext|
+          ext = ext.to_s
+          raise ArgumentError, "Invalid resolve extension: #{ext}" if ext.include?(",")
+          ext
+        end
+        flags << "--resolve-extensions=#{exts.join(",")}"
+      end
+      get_flag(options, :public_path, String) { |v| flags << "--public-path=#{v}" }
+      get_flag(options, :entry_names, String) { |v| flags << "--entry-names=#{v}" }
+      get_flag(options, :chunk_names, String) { |v| flags << "--chunk-names=#{v}" }
+      get_flag(options, :asset_names, String) { |v| flags << "--asset-names=#{v}" }
+      get_flag(options, :main_fields, Array) do |v|
+        values = v.map do |value|
+          value = value.to_s
+          raise ArgumentError, "Invalid main field: #{value}" if value.include?(",")
+          value
+        end
+        flags << "--main-fields=#{values.join(",")}"
+      end
+      get_flag(options, :conditions, Array) do |v|
+        values = v.map do |value|
+          value = value.to_s
+          raise ArgumentError, "Invalid condition: #{value}" if value.include?(",")
+          value
+        end
+        flags << "--conditions=#{values.join(",")}"
+      end
+      get_flag(options, :external, Array) { |v| v.each { |name| flags << "--external:#{name}" } }
+      get_flag(options, :banner, Hash) do |v|
+        v.each do |type, value|
+          raise ArgumentError, "Invalid banner file type: #{type}" if type.include?("=")
+          flags << "--banner:#{type}=#{value}"
+        end
+      end
+      get_flag(options, :footer, Hash) do |v|
+        v.each do |type, value|
+          raise ArgumentError, "Invalid footer file type: #{type}" if type.include?("=")
+          flags << "--footer:#{type}=#{value}"
+        end
+      end
+      get_flag(options, :inject, Array) { |v| v.each { |name| flags << "--inject:#{name}" } }
+      get_flag(options, :loader, Hash) do |v|
+        v.each do |ext, loader|
+          raise ArgumentError, "Invalid loader extension: #{ext}" if ext.include?("=")
+          flags << "--loader:#{ext}=#{loader}"
+        end
+      end
+      get_flag(options, :out_extension, Hash) do |v|
+        v.each do |ext, extension|
+          raise ArgumentError, "Invalid out extension: #{ext}" if ext.include?("=")
+          flags << "--out-extension:#{ext}=#{extension}"
+        end
+      end
+      entries = []
+      get_flag(options, :entry_points, ARRAY_OR_OBJECT) do |v|
+        if v.is_a?(Array)
+          v.each { |entry_point| entries << ["", entry_point] }
+        else
+          v.each { |key, entry_point| entries << [key.to_s, entry_point.to_s] }
+        end
+      end
+      stdin_resolve_dir = nil
+      stdin_contents = nil
+      get_flag(options, :stdin, Hash) do |v|
+        stdin_options = v.dup
+        stdin_contents = ""
+        get_flag(stdin_options, :contents, String) { |v| stdin_contents = v }
+        get_flag(stdin_options, :resolve_dir, String) { |v| stdin_resolve_dir = v }
+        get_flag(stdin_options, :sourcefile, String) { |v| flags << "--sourcefile=#{v}" }
+        get_flag(stdin_options, :loader, String) { |v| flags << "--loader=#{v}" }
+        raise ArgumentError, "Invalid option in stdin options: #{stdin_options.keys.first}" unless stdin_options.empty?
+      end
+      node_paths = []
+      get_flag(options, :node_paths, Array) { |v| v.each { |path| node_paths << path.to_s } }
+      write = true
+      get_flag(options, :write, BOOL) { |v| write = v }
+      abs_working_dir = nil
+      get_flag(options, :abs_working_dir, String) { |v| abs_working_dir = v }
+      incremental = false
+      get_flag(options, :incremental, BOOL) { |v| incremental = v }
+      raise ArgumentError, "Invalid option in build() call: #{options.keys.first}" unless options.empty?
+      {
+        entries: entries,
+        flags: flags,
+        write: write,
+        stdin_contents: stdin_contents,
+        stdin_resolve_dir: stdin_resolve_dir,
+        abs_working_dir: abs_working_dir,
+        incremental: incremental,
+        node_paths: node_paths,
+        watch: watch_mode
+      }
+    end
+
+    def push_log_flags(flags, options, log_level_default)
+      get_flag(options, :color, BOOL) { |v| flags << "--color=#{v}" if v }
+      log_level = log_level_default
+      get_flag(options, :log_level, STRING_OR_SYMBOL) { |v| log_level = v }
+      flags << "--log-level=#{log_level}"
+      log_limit = 0
+      get_flag(options, :log_limit, Numeric) { |v| log_limit = v }
+      flags << "--log-limit=#{log_limit}"
+    end
+
+    def push_common_flags(flags, options)
+      get_flag(options, :source_root, String) { |v| flags << "--source-root=#{v}" }
+      get_flag(options, :sources_content, BOOL) { |v| flags << "--sources-content=#{v}" }
+      get_flag(options, :target, STRING_OR_ARRAY) do |v|
+        v = [v] unless Array === v
+        targets = v.map do |t|
+          t = t.to_s
+          raise ArgumentError, "Invalid target: #{t}" if t.include?(",")
+          t
+        end
+        flags << "--target=#{targets.join(",")}"
+      end
+      get_flag(options, :format, String) { |v| flags << "--format=#{v}" }
+      get_flag(options, :global_name, String) { |v| flags << "--global-name=#{v}" }
+      get_flag(options, :minify, BOOL) { |v| flags << "--minify" if v }
+      get_flag(options, :minify_syntax, BOOL) { |v| flags << "--minify-syntax" if v }
+      get_flag(options, :minify_whitespace, BOOL) { |v| flags << "--minify-whitespace" if v }
+      get_flag(options, :minify_identifiers, BOOL) { |v| flags << "--minify-identifiers" if v }
+      get_flag(options, :charset, String) { |v| flags << "--charset=#{v}" }
+      get_flag(options, :tree_shaking, STRING_OR_BOOL) { |v| flags << "--tree-shaking=#{v}" if v != true }
+      get_flag(options, :jsx_factory, String) { |v| flags << "--jsx-factory=#{v}" }
+      get_flag(options, :jsx_fragment, String) { |v| flags << "--jsx-fragment=#{v}" }
+      get_flag(options, :define, Hash) do |v|
+        v.each do |key, value|
+          raise "Invalid define: #{key}" if key.include? "="
+          flags << "--define:#{key}=#{value}"
+        end
+      end
+      get_flag(options, :pure, Array) do |v|
+        v.each { |fn| flags << "--pure:#{fn}" }
+      end
+      get_flag(options, :keep_names, BOOL) { |v| flags << "--keep-names" if v }
+    end
+
+    def get_flag(options, sym, check)
+      return unless options.has_key?(sym)
+      value = options.delete(sym)
+      raise "#{sym} must be #{check}" unless check === value
+      yield value
+    end
+  end
+end

data/lib/esbuild/packet.rb

@@ -0,0 +1,3 @@
+module Esbuild
+  Packet = Struct.new(:id, :is_request, :value)
+end

data/lib/esbuild/serve_result.rb

@@ -0,0 +1,22 @@
+module Esbuild
+  class ServeResult
+    def initialize(response, wait, stop)
+      @port = response["port"]
+      @host = response["host"]
+      @wait = wait
+      @stop = stop
+      @is_stopped = false
+    end
+
+    def wait
+      @wait.wait!
+      @wait.value
+    end
+
+    def stop
+      return if @is_stopped
+      @is_stopped = true
+      @stop.call
+    end
+  end
+end

data/lib/esbuild/service.rb

@@ -0,0 +1,279 @@
+require "concurrent"
+require "esbuild/stdio_protocol"
+require "esbuild/flags"
+require "esbuild/build_result"
+require "esbuild/serve_result"
+require "esbuild/build_state"
+require "esbuild/transform_result"
+
+module Esbuild
+  class Service
+    # TODO: plugins
+
+    def initialize
+      @request_id = 0
+      @serve_id = 0
+      @build_key = 0
+      @first_packet = true
+      @response_callbacks = Concurrent::Map.new
+      @plugin_callbacks = Concurrent::Map.new
+      @watch_callbacks = Concurrent::Map.new
+      @serve_callbacks = Concurrent::Map.new
+      @buffer = String.new(encoding: Encoding::BINARY)
+
+      child_read, child_stdout = IO.pipe
+      child_stdin, @child_write = IO.pipe
+      bin = binary_path
+      pid = spawn(bin, "--service=#{ESBUILD_VERSION}", "--ping", out: child_stdout, err: :err, in: child_stdin)
+      child_stdin.close
+      child_stdout.close
+
+      Thread.new { worker_thread(pid, child_read) }
+    end
+
+    def build_or_serve(options, serve_options = nil)
+      key = @build_key
+      @build_key += 1
+      opts = Flags.flags_for_build_options(options)
+      on_rebuild = opts[:watch]&.fetch(:on_rebuild, nil)
+
+      request = {
+        "command" => "build",
+        "key" => key,
+        "entries" => opts[:entries],
+        "flags" => opts[:flags],
+        "write" => opts[:write],
+        "stdinContents" => opts[:stdin_contents],
+        "stdinResolveDir" => opts[:stdin_resolve_dir],
+        "absWorkingDir" => opts[:abs_working_dir] || Dir.pwd,
+        "incremental" => opts[:incremental],
+        "nodePaths" => opts[:node_paths],
+        "hasOnRebuild" => !!on_rebuild
+      }
+      serve = serve_options && build_serve_data(serve_options, request)
+
+      response = send_request(request)
+      if serve
+        ServeResult.new(response, serve[:wait], serve[:stop])
+      else
+        build_state = BuildState.new(self, on_rebuild)
+        build_state.response_to_result(response)
+      end
+    end
+
+    def start_watch(watch_id, proc)
+      @watch_callbacks[watch_id] = proc
+    end
+
+    def stop_watch(watch_id)
+      @watch_callbacks.delete(watch_id)
+      send_request(
+        "command" => "watch-stop",
+        "watchID" => watch_id
+      )
+    end
+
+    def transform(input, options)
+      flags = Flags.flags_for_transform_options(options)
+      res = send_request(
+        "command" => "transform",
+        "flags" => flags,
+        "inputFS" => false,
+        "input" => input
+      )
+
+      unless res["errors"].empty?
+        raise BuildFailureError, res["errors"], res["warnings"]
+      end
+
+      TransformResult.new(res)
+    end
+
+    def send_request(request)
+      @request_id += 1
+      id = @request_id
+      encoder = StdioProtocol::PacketEncoder.new
+      encoded = encoder.encode_packet(Packet.new(id, true, request))
+      @child_write.write encoded
+      ivar = Concurrent::IVar.new
+      @response_callbacks[id] = ivar
+      ivar.wait!
+      ivar.value
+    end
+
+    private
+
+    def read_from_stdout(chunk)
+      @buffer << chunk
+      offset = 0
+      while offset + 4 < @buffer.bytesize
+        size = @buffer.getbyte(offset) | (@buffer.getbyte(offset + 1) << 8) | (@buffer.getbyte(offset + 2) << 16) | (@buffer.getbyte(offset + 3) << 24)
+        if offset + 4 + size > @buffer.bytesize
+          break
+        end
+        offset += 4
+        handle_incoming_packet(@buffer, offset, size)
+        offset += size
+      end
+      @buffer.slice!(0, offset)
+    end
+
+    def send_response(id, response)
+      encoder = StdioProtocol::PacketEncoder.new
+      encoded = encoder.encode_packet(Packet.new(id, false, response))
+      @child_write.write encoded
+    end
+
+    def build_serve_data(options, request)
+      serve_id = @serve_id
+      @serve_id += 1
+      options = options.dup
+      on_request = nil
+      Flags.get_flag(options, :port, Numeric) { |v| request[:port] = v }
+      Flags.get_flag(options, :host, String) { |v| request[:host] = v }
+      Flags.get_flag(options, :serve_dir, String) { |v| request[:serveDir] = v }
+      Flags.get_flag(options, :on_request, Proc) { |v| on_request = v }
+      raise ArgumentError, "Invalid option in serve() call: #{options.keys.first}" unless options.empty?
+      request[:serve] = {serveID: serve_id}
+      wait = Concurrent::IVar.new
+      @serve_callbacks[serve_id] = {
+        on_request: on_request,
+        on_wait: ->(error) do
+          @serve_callbacks.delete(serve_id)
+          if error
+            wait.fail StandardError.new(error)
+          else
+            wait.set
+          end
+        end
+      }
+
+      {
+        wait: wait,
+        stop: -> do
+          send_request("command" => "serve-stop", "serveID" => serve_id)
+        end
+      }
+    end
+
+    def handle_request(id, request)
+      case request["command"]
+      when "ping"
+        send_response(id, {})
+      when "resolve", "load"
+        callback = @plugin_callbacks[request["key"]]
+        response = {}
+        if callback
+          response = callback.call(request)
+        end
+        send_response(id, response)
+      when "serve-request"
+        callback = @serve_callbacks[request["serveID"]]
+        if callback && callback[:on_request]
+          on_request = callback[:on_request]
+          if on_request.arity == 1
+            on_request.call(request["args"])
+          else
+            on_request.call
+          end
+        end
+        send_response(id, {})
+      when "serve-wait"
+        callback = @serve_callbacks[request["serveID"]]
+        if callback && callback[:on_wait]
+          callback[:on_wait].call(request["error"])
+        end
+        send_response(id, {})
+      when "watch-rebuild"
+        callback = @watch_callbacks[request["watchID"]]
+        callback&.call(nil, request["args"])
+        send_response(id, {})
+      else
+        raise "Unknown command #{request["command"]}"
+      end
+    rescue => e
+      send_response(id, {errors: [{text: e.message}]})
+    end
+
+    def handle_incoming_packet(bytes, offset, size)
+      if @first_packet
+        @first_packet = false
+        version = bytes.slice(offset, size)
+        raise "Version mismatch #{ESBUILD_VERSION} != #{version}" if ESBUILD_VERSION != version
+
+        return
+      end
+
+      decoder = StdioProtocol::PacketDecoder.new(bytes, offset, size)
+      packet = decoder.decode_packet
+
+      if packet.is_request
+        handle_request packet.id, packet.value
+      else
+        callback = @response_callbacks.delete(packet.id)
+        if packet.value["error"]
+          callback.fail(StandardError.new(packet.value["error"]))
+        else
+          callback.set(packet.value)
+        end
+      end
+    end
+
+    def worker_thread(pid, child_read)
+      buffer = String.new(encoding: Encoding::BINARY)
+      loop do
+        done = Process.waitpid(pid, Process::WNOHANG)
+        if done
+          error = StandardError.new("Closed")
+          close_callbacks(error)
+          break
+        end
+
+        begin
+          chunk = child_read.read_nonblock(16384, buffer)
+          read_from_stdout chunk
+        rescue IO::WaitReadable
+          IO.select([child_read])
+          retry
+        end
+      end
+    ensure
+      @child_write.close
+      child_read.close
+    end
+
+    def close_callbacks(error)
+      @response_callbacks.each_value do |callback|
+        callback.fail(error)
+      end
+      @response_callbacks.clear
+    end
+
+    def binary_path
+      ENV["ESBUILD_BINARY_PATH"] || File.expand_path("../../bin/esbuild", __dir__)
+    end
+  end
+
+  class BuildFailureError < StandardError
+    attr_reader :errors
+    attr_reader :warnings
+
+    def initialize(errors, warnings)
+      @errors = errors
+      @warnings = warnings
+      summary = ""
+      unless errors.empty?
+        limit = 5
+        details = errors.slice(0, limit + 1).each_with_index.map do |error, index|
+          break "\n..." if index == limit
+          location = error["location"]
+          break "\nerror: #{error["text"]}" unless location
+          "\n#{location["file"]}:#{location["line"]}:#{location["column"]}: error: #{error["text"]}"
+        end.join
+        summary = "with #{errors.size} error#{errors.size > 1 ? "s" : ""}:#{details}"
+      end
+
+      super "Build failed#{summary}"
+    end
+  end
+end

data/lib/esbuild/stdio_protocol.rb

@@ -0,0 +1,150 @@
+require "esbuild/packet"
+
+module Esbuild
+  module StdioProtocol
+    extend self
+
+    class PacketDecoder
+      attr_reader :offset
+
+      def initialize(buf, offset, size)
+        @buf = buf
+        @offset = offset
+        @end = offset + size
+      end
+
+      def decode_packet
+        id = read32
+        is_request = (id & 1) == 0
+        id >>= 1
+
+        value = visit
+        Packet.new(id, is_request, value)
+      end
+
+      def visit
+        kind = read8
+        case kind
+        when 0
+          # Null
+          nil
+        when 1
+          # Bool
+          read8 == 1
+        when 2
+          # Integer
+          read32
+        when 3
+          # String
+          read_string.force_encoding(Encoding::UTF_8)
+        when 4
+          # Bytes
+          read_string
+        when 5
+          # Array
+          size = read32
+          size.times.map { visit }
+        when 6
+          # Object
+          result = {}
+          size = read32
+          size.times do
+            key = read_string.force_encoding(Encoding::UTF_8)
+            result[key] = visit
+          end
+          result
+        else
+          raise ArgumentError, "Invalid packet #{kind}"
+        end
+      end
+
+      def read_string
+        size = read32
+        result = @buf.byteslice(@offset, size)
+        @offset += size
+        result
+      end
+
+      def read8
+        raise ArgumentError, "Reading past buffer" if @offset >= @end
+        byte = @buf.getbyte(@offset)
+        @offset += 1
+        byte
+      end
+
+      def read32
+        read8 | (read8 << 8) | (read8 << 16) | (read8 << 24)
+      end
+    end
+
+    class PacketEncoder
+      def initialize
+        @format = ""
+        @elements = []
+        @size = 0
+      end
+
+      def encode_packet(packet)
+        write32 0
+        write32((packet.id << 1) | (packet.is_request ? 0 : 1))
+        visit(packet.value)
+        @elements[0] = @size - 4
+        @elements.pack(@format)
+      end
+
+      def visit(value)
+        case value
+        when nil
+          write8 0
+        when true, false
+          write8 1
+          write8(value ? 1 : 0)
+        when Integer
+          write8 2
+          write32 value
+        when String
+          if value.encoding == Encoding::BINARY
+            write8 4
+          else
+            write8 3
+            value = value.encode(Encoding::UTF_8) unless value.encoding == Encoding::UTF_8
+          end
+          write_string value
+        when Array
+          write8 5
+          write32 value.size
+          value.each { |item| visit(item) }
+        when Hash
+          write8 6
+          write32 value.size
+          value.each do |key, val|
+            write_string key
+            visit val
+          end
+        else
+          raise ArgumentError, "Don't know how to encode #{value.inspect}"
+        end
+      end
+
+      def write_string(string)
+        string = string.to_s
+        write32 string.bytesize
+        @elements << string
+        @format << "a*"
+        @size += string.bytesize
+      end
+
+      def write32(value)
+        @elements << value
+        @format << "L<"
+        @size += 4
+      end
+
+      def write8(value)
+        @elements << value
+        @format << "C"
+        @size += 1
+      end
+    end
+  end
+end

data/lib/esbuild/transform_result.rb

@@ -0,0 +1,25 @@
+module Esbuild
+  class TransformResult
+    attr_reader :code, :map, :warnings
+
+    def initialize(result)
+      @code = read_file(result["codeFS"], result["code"])
+      @map = read_file(result["mapFS"], result["map"])
+      @warnings = result["warnings"]
+    end
+
+    private
+
+    # If the files are too big, esbuild will create a tempfile to pass back the result
+    # We need to delete it
+    def read_file(fs, name)
+      if fs
+        contents = File.read(name)
+        File.delete(name)
+        contents
+      else
+        name
+      end
+    end
+  end
+end

data/lib/esbuild/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Esbuild
+  VERSION = "0.1.0"
+  ESBUILD_VERSION = "0.11.9"
+end

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: esbuild
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Bouke van der Bijl
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2021-04-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.8
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.8
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.14.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.14.4
+- !ruby/object:Gem::Dependency
+  name: standard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.4
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description:
+email:
+- i@bou.ke
+executables: []
+extensions:
+- Rakefile
+extra_rdoc_files: []
+files:
+- ".github/workflows/main.yml"
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- esbuild.gemspec
+- lib/esbuild.rb
+- lib/esbuild/binary_installer.rb
+- lib/esbuild/build_result.rb
+- lib/esbuild/build_state.rb
+- lib/esbuild/flags.rb
+- lib/esbuild/packet.rb
+- lib/esbuild/serve_result.rb
+- lib/esbuild/service.rb
+- lib/esbuild/stdio_protocol.rb
+- lib/esbuild/transform_result.rb
+- lib/esbuild/version.rb
+homepage: https://github.com/bouk/esbuild-ruby
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.3
+signing_key:
+specification_version: 4
+summary: Use esbuild from Ruby
+test_files: []