klenod-build 0.0.1

data/lib/klenod/build/plugins/image_plugin.rb

@@ -0,0 +1,401 @@
+# frozen_string_literal: true
+
+require "image_size"
+require "json"
+require "rmagick"
+require "uri"
+
+require_relative "../asset"
+require_relative "../dependency"
+require_relative "../hashing"
+require_relative "../load_result"
+require_relative "../plugin"
+require_relative "../transform_result"
+
+module Klenod
+  module Build
+    module Plugins
+      module ImagePlugin
+        def self.new(...)
+          Plugin.new(...)
+        end
+
+        class Plugin < Klenod::Build::Plugin
+          EXTENSIONS = [".avif", ".gif", ".jpeg", ".jpg", ".png", ".webp"].freeze
+          IMAGE_RUNTIME_SPECIFIER = "virtual:klenod/image"
+          IMAGE_RUNTIME_MODULE_ID = ModuleId.new("#{IMAGE_RUNTIME_SPECIFIER}.rb", nil)
+
+          ImageDefaultKey = Data.define(:source_path, :source_hash, :format, :quality)
+          ImageVariantKey = Data.define(:source_path, :source_hash, :width, :format, :quality)
+
+          def initialize(widths: [], formats: nil)
+            @widths = widths
+            @formats = formats
+            @default_asset_cache = {}
+            @variant_cache = {}
+          end
+
+          def resolve(dependency, _context)
+            return nil unless dependency.specifier == IMAGE_RUNTIME_SPECIFIER
+
+            ResolvedDependency.new(dependency, IMAGE_RUNTIME_MODULE_ID, {virtual: true})
+          end
+
+          def load(module_id, context)
+            return image_runtime_source if module_id.scheme == :virtual && module_id == IMAGE_RUNTIME_MODULE_ID
+            return nil unless EXTENSIONS.include?(module_id.extname)
+
+            source_path = context.absolute_path(module_id)
+            source_hash = Hashing.file_hexdigest(source_path)
+            dimensions = image_dimensions(source_path)
+            image_options = image_options_for(module_id)
+            asset = default_image_asset(module_id, source_path, source_hash, dimensions, image_options, context.asset_generation_queue)
+            variant_assets = generate_variant_assets(module_id, source_path, source_hash, dimensions, image_options, context.asset_generation_queue)
+            javascript_asset = javascript_image_asset(module_id, asset, variant_assets)
+            assets = [asset, *variant_assets, javascript_asset]
+            image_runtime_dependency =
+              Dependency
+                .create(
+                  specifier: IMAGE_RUNTIME_SPECIFIER,
+                  importer_id: module_id,
+                  kind: :image_runtime
+                )
+                .with(id: "#{module_id}:image_runtime")
+
+            transform =
+              TransformResult.new(
+                image_module_source(module_id, assets, image_runtime_dependency),
+                [image_runtime_dependency],
+                nil,
+                assets,
+                [],
+                {image_javascript_asset_path: javascript_asset.output_path}
+              )
+            LoadResult.new(
+              image_source(module_id),
+              source_hash,
+              transform
+            )
+          end
+
+          def import_value(_resolved_dependency, record, context)
+            return nil unless EXTENSIONS.include?(record.id.extname)
+
+            context.mods.fetch(record.id).const_get(:Exports)::Default
+          end
+
+          def runtime_import_value(_resolved_dependency, record, _context)
+            return Runtime::DefaultImport.new(:Default) if EXTENSIONS.include?(record.id.extname)
+
+            super
+          end
+
+          private
+
+          Dimensions = Data.define(:width, :height, :format)
+
+          def image_dimensions(path)
+            size = ImageSize.path(path)
+            Dimensions.new(size.width, size.height, size.format)
+          rescue ImageSize::FormatError
+            Dimensions.new(nil, nil, nil)
+          end
+
+          def default_image_asset(module_id, source_path, source_hash, dimensions, image_options, queue)
+            return static_image_asset(module_id, source_path, source_hash, dimensions) unless generated_default_image?(image_options)
+
+            format = default_image_format(module_id, image_options)
+            key = ImageDefaultKey.new(module_id.path, source_hash, format, image_options.quality)
+            @default_asset_cache[key] ||= generated_default_image_asset(module_id, source_path, source_hash, dimensions, format, image_options.quality, queue)
+          end
+
+          def generated_default_image?(image_options)
+            return true if image_options.explicit_formats && image_options.formats.any?
+
+            !image_options.quality.nil?
+          end
+
+          def default_image_format(module_id, image_options)
+            return image_options.formats.fetch(0) if image_options.explicit_formats && image_options.formats.any?
+
+            module_id.extname.delete_prefix(".")
+          end
+
+          def static_image_asset(module_id, source_path, source_hash, dimensions)
+            hash = source_hash[0, 16]
+            Asset.new(
+              module_id.path,
+              hash,
+              "/assets/#{asset_name(module_id)}.#{hash}#{module_id.extname}",
+              source_path,
+              nil,
+              content_type(module_id.extname),
+              {
+                type: :image,
+                width: dimensions.width,
+                height: dimensions.height,
+                format: dimensions.format
+              }
+            )
+          end
+
+          def generated_default_image_asset(module_id, source_path, source_hash, dimensions, format, quality, queue)
+            format = format.downcase
+            extname = ".#{format}"
+            hash = Hashing.short("#{source_hash}:default:#{format}:#{quality}")
+            metadata = {
+              type: :image,
+              width: dimensions.width,
+              height: dimensions.height,
+              format: format.to_sym
+            }
+            metadata[:quality] = quality if quality
+
+            Asset.generated(
+              module_id.path,
+              hash,
+              "/assets/#{asset_name(module_id)}.#{hash}#{extname}",
+              source_path,
+              content_type(extname),
+              metadata,
+              writer: ->(io) { write_image_bytes(source_path, format, quality, io) },
+              queue: queue,
+              queue_kind: :cpu
+            ) do
+              generate_image_bytes(source_path, format, quality:)
+            end
+          end
+
+          def generate_variant_assets(module_id, source_path, source_hash, dimensions, image_options, queue)
+            return [] if dimensions.width.nil? || dimensions.height.nil?
+
+            return [] if image_options.widths.empty?
+
+            image_options.formats.flat_map do |format|
+              image_options.widths.filter_map do |width|
+                next if width <= 0
+
+                key = ImageVariantKey.new(module_id.path, source_hash, width, format.downcase, image_options.quality)
+                @variant_cache[key] ||= variant_asset(module_id, source_path, dimensions, source_hash, width, format, image_options.quality, queue)
+              end
+            end
+          end
+
+          ImageOptions = Data.define(:widths, :formats, :explicit_formats, :quality)
+
+          def image_runtime_source
+            <<~RUBY
+              Image =
+                Data.define(:src, :width, :height, :content_type, :variants) do
+                  def srcset
+                    return nil if variants.empty?
+
+                    variants.map { "\#{it.src} \#{it.descriptor}" }.join(", ")
+                  end
+
+                  def sizes
+                    display_width = variants.filter_map(&:width).max || width
+                    return nil unless display_width
+
+                    "(max-width: \#{display_width}px) 100vw, \#{display_width}px"
+                  end
+                end
+
+              ImageVariant = Data.define(:src, :width, :height, :content_type, :format, :descriptor, :metadata)
+            RUBY
+          end
+
+          def image_source(module_id)
+            "# image asset: #{module_id}\n"
+          end
+
+          def image_module_source(module_id, assets, image_runtime_dependency)
+            asset = image_asset(assets)
+            variants = image_variant_assets(assets).map { |variant_asset| image_variant_source(variant_asset) }
+
+            <<~RUBY
+              ImageRuntime = __klenod_import__(#{image_runtime_dependency.id.inspect})
+              Default =
+                ImageRuntime::Image.new(
+                  src: #{asset.output_path.inspect},
+                  width: #{asset.metadata[:width].inspect},
+                  height: #{asset.metadata[:height].inspect},
+                  content_type: #{asset.content_type.inspect},
+                  variants: [
+                    #{variants.join(",\n    ")}
+                  ]
+                )
+
+            RUBY
+          end
+
+          def image_variant_source(asset)
+            <<~RUBY.chomp
+              ImageRuntime::ImageVariant.new(
+                src: #{asset.output_path.inspect},
+                width: #{asset.metadata[:width].inspect},
+                height: #{asset.metadata[:height].inspect},
+                content_type: #{asset.content_type.inspect},
+                format: #{asset.metadata[:format].inspect},
+                descriptor: #{asset.metadata[:descriptor].inspect},
+                metadata: #{asset.metadata.inspect}
+              )
+            RUBY
+          end
+
+          def javascript_image_asset(module_id, asset, variant_assets)
+            code = javascript_image_module_source(asset, variant_assets)
+            hash = Hashing.short(code)
+            Asset.new(
+              module_id.path,
+              hash,
+              "#{asset.output_path}.js",
+              nil,
+              code,
+              "application/javascript",
+              {type: :image_javascript_metadata, image_metadata: true, image_asset_path: asset.output_path}
+            )
+          end
+
+          def javascript_image_module_source(asset, variant_assets)
+            variants = variant_assets.map { |variant_asset| javascript_image_variant(variant_asset) }
+            srcset = variant_assets.empty? ? nil : variant_assets.map { "#{it.output_path} #{it.metadata[:descriptor]}" }.join(", ")
+            display_width = variant_assets.filter_map { it.metadata[:width] }.max || asset.metadata[:width]
+            sizes = display_width ? "(max-width: #{display_width}px) 100vw, #{display_width}px" : nil
+            metadata = {
+              src: asset.output_path,
+              width: asset.metadata[:width],
+              height: asset.metadata[:height],
+              contentType: asset.content_type,
+              variants: variants,
+              srcset: srcset,
+              sizes: sizes
+            }
+
+            "export default #{JSON.generate(metadata)};\n"
+          end
+
+          def javascript_image_variant(asset)
+            {
+              src: asset.output_path,
+              width: asset.metadata[:width],
+              height: asset.metadata[:height],
+              contentType: asset.content_type,
+              format: asset.metadata[:format],
+              descriptor: asset.metadata[:descriptor],
+              metadata: asset.metadata
+            }
+          end
+
+          def image_asset(assets)
+            assets.find { it.metadata[:type] == :image } || assets.fetch(0)
+          end
+
+          def image_variant_assets(assets)
+            assets.select { it.metadata[:type] == :image_variant }
+          end
+
+          def image_options_for(module_id)
+            query = URI.decode_www_form(module_id.query || "").to_h
+            widths =
+              if query["width"]
+                query["width"].split(",").filter_map { |value| Integer(value, exception: false) }
+              else
+                @widths
+              end
+            explicit_formats = query.key?("format")
+            formats =
+              if explicit_formats
+                query["format"].split(",")
+              else
+                @formats || [module_id.extname.delete_prefix(".")]
+              end
+
+            ImageOptions.new(widths.uniq, formats.map(&:downcase).uniq, explicit_formats, image_quality(query["quality"]))
+          end
+
+          def image_quality(value)
+            return nil if value.nil?
+
+            quality = Integer(value, exception: false)
+            return nil unless quality&.between?(1, 100)
+
+            quality
+          end
+
+          def variant_asset(module_id, source_path, dimensions, source_hash, width, format, quality, queue)
+            format = format.downcase
+            extname = ".#{format}"
+            descriptor = "#{width}w"
+            hash = Hashing.short("#{source_hash}:#{width}:#{format}:#{quality}")
+            output_path = "/assets/#{asset_name(module_id)}.#{width}w.#{hash}#{extname}"
+            metadata = {
+              type: :image_variant,
+              width: width,
+              height: scaled_height(dimensions, width),
+              format: format.to_sym,
+              descriptor: descriptor,
+              source_width: width
+            }
+            metadata[:quality] = quality if quality
+
+            Asset.generated(
+              module_id.path,
+              hash,
+              output_path,
+              source_path,
+              content_type(extname),
+              metadata,
+              writer: ->(io) { write_variant_bytes(source_path, width, format, quality, io) },
+              queue: queue,
+              queue_kind: :cpu
+            ) do
+              generate_image_bytes(source_path, format, width: width, quality:)
+            end
+          end
+
+          def generate_image_bytes(source_path, format, width: nil, quality: nil)
+            image = Magick::Image.read(source_path.to_s).first
+            output_image = width ? image.resize_to_fit(width) : image
+            output_image.to_blob do |info|
+              info.format = format.upcase
+              info.quality = quality if quality
+            end
+          ensure
+            output_image&.destroy! if output_image && output_image != image
+            image&.destroy!
+          end
+
+          def write_variant_bytes(source_path, width, format, quality, io)
+            io.write(generate_image_bytes(source_path, format, width: width, quality:))
+          end
+
+          def write_image_bytes(source_path, format, quality, io)
+            io.write(generate_image_bytes(source_path, format, quality:))
+          end
+
+          def scaled_height(dimensions, width)
+            return nil if dimensions.width.nil? || dimensions.height.nil? || dimensions.width.zero?
+
+            (dimensions.height.to_f * width / dimensions.width).round
+          end
+
+          def asset_name(module_id)
+            File.basename(module_id.path, module_id.extname).gsub(/[^A-Za-z0-9]+/, "_")
+          end
+
+          def content_type(extname)
+            case extname
+            when ".avif" then "image/avif"
+            when ".gif" then "image/gif"
+            when ".jpeg", ".jpg" then "image/jpeg"
+            when ".png" then "image/png"
+            when ".webp" then "image/webp"
+            else "application/octet-stream"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/klenod/build/plugins/intl_plugin.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "toml-rb"
+
+require_relative "../plugin"
+
+module Klenod
+  module Build
+    module Plugins
+      module IntlPlugin
+        def self.new(...)
+          Plugin.new(...)
+        end
+
+        class Plugin < Klenod::Build::Plugin
+          INTL_FILE_RE = /\.intl\.(?<locale>[^\/]+)\.toml\z/
+
+          def translations_for(context, module_id)
+            base = module_id.path.delete_suffix(module_id.extname)
+            pattern = context.absolute_path(ModuleId.new("#{base}.intl.*.toml", nil)).to_s
+
+            Dir
+              .glob(pattern)
+              .sort
+              .to_h do |path|
+                locale = File.basename(path).match(INTL_FILE_RE)[:locale]
+                [locale, TomlRB.load_file(path)]
+              end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/klenod/build/plugins/markdown_compiler.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+previous_verbose = $VERBOSE
+begin
+  $VERBOSE = nil
+  require "kramdown"
+  require "kramdown-parser-gfm"
+ensure
+  $VERBOSE = previous_verbose
+end
+
+module Klenod
+  module Build
+    module Plugins
+      class MarkdownCompiler
+        ESCAPED_INTERPOLATION_SENTINEL = "\uE000klenod_escaped_interpolation\uE000"
+
+        def initialize(factory:, components_source: "{}")
+          @factory = factory
+          @components_source = components_source
+        end
+
+        def compile(source, interpolate: false)
+          source = protect_escaped_interpolation(source) if interpolate
+          document = Kramdown::Document.new(source, input: "GFM")
+          compile_children(document.root.children, interpolate: interpolate)
+        end
+
+        private
+
+        def compile_children(children, parent: nil, interpolate: false)
+          expressions = compile_child_expressions(children, parent: parent, interpolate: interpolate)
+          return "nil" if expressions.empty?
+          return expressions.fetch(0) if expressions.length == 1
+
+          "[#{expressions.join(", ")}]"
+        end
+
+        def compile_child_expressions(children, parent:, interpolate:, table_section: nil)
+          children.flat_map { |child| compile_node(child, parent: parent, table_section: table_section, interpolate: interpolate) }.compact
+        end
+
+        def compile_node(node, parent: nil, table_section: nil, interpolate: false)
+          case node.type
+          when :root
+            [compile_children(node.children, parent: node, interpolate: interpolate)]
+          when :blank
+            nil
+          when :text
+            text_expressions(node.value, interpolate: interpolate)
+          when :p
+            return compile_child_expressions(node.children, parent: node, interpolate: interpolate) if node.options[:transparent]
+
+            [factory_call(:p, node.children, attrs: node.attr, parent: node, interpolate: interpolate)]
+          when :header
+            [factory_call(:"h#{node.options.fetch(:level)}", node.children, attrs: node.attr, parent: node, interpolate: interpolate)]
+          when :em, :strong, :a, :blockquote, :ul, :ol, :li, :table
+            [factory_call(node.type, node.children, attrs: node.attr, parent: node, interpolate: interpolate)]
+          when :thead, :tbody
+            [factory_call(node.type, node.children, attrs: node.attr, parent: node, table_section: node.type, interpolate: interpolate)]
+          when :tr
+            [factory_call(node.type, node.children, attrs: node.attr, parent: node, table_section: table_section, interpolate: interpolate)]
+          when :td
+            [factory_call((table_section == :thead) ? :th : :td, node.children, attrs: node.attr, parent: node, table_section: table_section, interpolate: interpolate)]
+          when :img, :hr, :br
+            [factory_call(node.type, [], attrs: node.attr, parent: node, interpolate: interpolate)]
+          when :codespan
+            [factory_call(:code, [node], raw_text: node.value, attrs: node.attr, parent: node, interpolate: interpolate)]
+          when :codeblock
+            code = factory_call(:code, [node], raw_text: node.value, attrs: node.attr, parent: node, interpolate: interpolate)
+            [factory_call(:pre, [], child_sources: [code], parent: node, interpolate: interpolate)]
+          when :html_element
+            [factory_call(node.value.to_sym, node.children, attrs: node.attr, parent: node, interpolate: interpolate)]
+          when :raw
+            [restore_escaped_interpolation(node.value.to_s).inspect]
+          else
+            [compile_children(node.children, parent: node, interpolate: interpolate)]
+          end
+        end
+
+        def factory_call(tag, children, parent:, attrs: {}, raw_text: nil, child_sources: nil, table_section: nil, interpolate: false)
+          child_sources ||=
+            if raw_text.nil?
+              compile_child_expressions(children, parent: parent, table_section: table_section, interpolate: interpolate)
+            else
+              [restore_escaped_interpolation(raw_text).inspect]
+            end
+          tag_source = tag_source(tag)
+          parts = [tag_source, *child_sources]
+          parts << "**#{attrs_source(attrs)}" unless attrs.empty?
+
+          "#{@factory}[#{parts.join(", ")}]"
+        end
+
+        def tag_source(tag)
+          "#{@components_source}.fetch(#{tag.inspect}, #{tag.inspect})"
+        end
+
+        def attrs_source(attrs)
+          attrs.transform_keys(&:to_sym).inspect
+        end
+
+        def text_expressions(text, interpolate:)
+          return [restore_escaped_interpolation(text).inspect] unless interpolate && text.include?("\#{")
+
+          expressions = []
+          buffer = +""
+          index = 0
+
+          while index < text.length
+            if text[index, 2] == "\#{"
+              expression, next_index = read_interpolation(text, index + 2)
+              if expression
+                expressions << restore_escaped_interpolation(buffer).inspect unless buffer.empty?
+                buffer.clear
+                expressions << "(#{expression})"
+                index = next_index
+              else
+                buffer << text[index]
+                index += 1
+              end
+            else
+              buffer << text[index]
+              index += 1
+            end
+          end
+
+          expressions << restore_escaped_interpolation(buffer).inspect unless buffer.empty?
+          expressions
+        end
+
+        def read_interpolation(text, index)
+          expression = +""
+          depth = 1
+          quote = nil
+          escaped = false
+
+          while index < text.length
+            char = text[index]
+
+            if quote
+              expression << char
+              if escaped
+                escaped = false
+              elsif char == "\\"
+                escaped = true
+              elsif char == quote
+                quote = nil
+              end
+            else
+              case char
+              when "\"", "'", "`"
+                quote = char
+              when "{"
+                depth += 1
+              when "}"
+                depth -= 1
+                return [expression.strip, index + 1] if depth.zero?
+              end
+
+              expression << char
+            end
+
+            index += 1
+          end
+
+          nil
+        end
+
+        def protect_escaped_interpolation(source)
+          source.gsub("\\\#{", ESCAPED_INTERPOLATION_SENTINEL)
+        end
+
+        def restore_escaped_interpolation(text)
+          text.gsub(ESCAPED_INTERPOLATION_SENTINEL, "\#{")
+        end
+      end
+    end
+  end
+end