bun_bun_bundle 0.1.0

data/lib/bun/plugins/index.js

@@ -0,0 +1,85 @@
+import {join} from 'path'
+import cssAliases from './cssAliases.js'
+import cssGlobs from './cssGlobs.js'
+import jsGlobs from './jsGlobs.js'
+
+const builtins = {cssAliases, cssGlobs, jsGlobs}
+const TYPE_REGEXES = {
+  css: /\.css$/,
+  js: /\.(js|ts|jsx|tsx)$/
+}
+
+// Combines transform functions into a single Bun plugin for a given file type.
+function transformPipeline(type, transforms) {
+  const filter = TYPE_REGEXES[type]
+
+  return {
+    name: `${type}-transforms`,
+    setup(build) {
+      build.onLoad({filter}, async args => {
+        let content = await Bun.file(args.path).text()
+        for (const transform of transforms)
+          content = await transform(content, args)
+        return {contents: content, loader: type}
+      })
+    }
+  }
+}
+
+// Resolves a plugin name or path into a transform function.
+async function loadFactory(name, root) {
+  if (builtins[name]) return builtins[name]
+
+  try {
+    const mod = await import(join(root, name))
+    console.log(` ▸ Loaded custom plugin: ${name}`)
+    return mod.default || mod
+  } catch (err) {
+    console.error(` ✖ Failed to load plugin "${name}": ${err.message}`)
+  }
+}
+
+// Resolves plugin names into transforms for a single type.
+async function resolveType(names, context) {
+  const transforms = []
+  const plugins = []
+
+  for (const name of names) {
+    const factory = await loadFactory(name, context.root)
+    if (typeof factory !== 'function') {
+      if (factory != null)
+        console.error(` ✖ Plugin "${name}" does not export a function`)
+      continue
+    }
+
+    const result = factory(context)
+    if (typeof result === 'function') transforms.push(result)
+    else if (result?.setup) plugins.push(result)
+    else console.error(` ✖ Plugin "${name}" returned an invalid value`)
+  }
+
+  return {transforms, plugins}
+}
+
+// Resolves plugin config into Bun plugin instances.
+export async function resolvePlugins(pluginConfig, context) {
+  const bunPlugins = []
+
+  if (!pluginConfig || typeof pluginConfig !== 'object') return bunPlugins
+
+  for (const [type, names] of Object.entries(pluginConfig)) {
+    if (!Array.isArray(names)) continue
+
+    if (!TYPE_REGEXES[type]) {
+      console.error(` ✖ Unknown plugin type "${type}"`)
+      continue
+    }
+
+    const {transforms, plugins} = await resolveType(names, context)
+    bunPlugins.push(...plugins)
+    if (transforms.length)
+      bunPlugins.unshift(transformPipeline(type, transforms))
+  }
+
+  return bunPlugins
+}

data/lib/bun/plugins/jsGlobs.js

@@ -0,0 +1,47 @@
+import {dirname, extname} from 'path'
+import {Glob} from 'bun'
+
+const REGEX = /import\s+(\w+)\s+from\s+['"]glob:([^'"]+)['"]/g
+
+// Compiles an object with a file path => default export mapping from a glob
+// pattern in JS import statements.
+// e.g. import components from 'glob:./components/**/*.js'
+//
+// ... will generate ...
+//
+// import _glob_components_theme from './components/theme.js'
+// import _glob_components_shared_tooltip from './components/shared/tooltip.js'
+// const components = {
+//   'components/theme': _glob_components_theme,
+//   'components/shared/tooltip': _glob_components_shared_tooltip
+// }
+export default function jsGlobs() {
+  return (content, args) => {
+    return content.replace(REGEX, (_, binding, pattern) => {
+      const dir = dirname(args.path)
+      const cleanPattern = pattern.replace(/^\.\//, '')
+      const glob = new Glob(cleanPattern)
+      const files = Array.from(glob.scanSync({cwd: dir})).sort()
+
+      if (!files.length) return `const ${binding} = {}`
+
+      const imports = []
+      const entries = []
+
+      for (const file of files) {
+        const ext = extname(file)
+        const key = file.slice(0, -ext.length)
+        const safe = `_glob_${key.replace(/[^a-zA-Z0-9]/g, '_')}`
+        imports.push(`import ${safe} from './${file}'`)
+        entries.push(`  '${key}': ${safe}`)
+      }
+
+      return [
+        ...imports,
+        `const ${binding} = {`,
+        entries.join(',\n'),
+        '}'
+      ].join('\n')
+    })
+  }
+}

data/lib/bun_bun_bundle/config.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module BunBunBundle
+  class Config
+    CONFIG_PATH = 'config/bun.json'
+
+    attr_reader :manifest_path, :out_dir, :public_path, :static_dirs,
+                :entry_points, :dev_server
+
+    def initialize(data = {})
+      @manifest_path = data.fetch('manifestPath', 'public/bun-manifest.json')
+      @out_dir = data.fetch('outDir', 'public/assets')
+      @public_path = data.fetch('publicPath', '/assets')
+      @static_dirs = data.fetch('staticDirs', %w[app/assets/images app/assets/fonts])
+      @entry_points = EntryPoints.new(data.fetch('entryPoints', {}))
+      @dev_server = DevServer.new(data.fetch('devServer', {}))
+    end
+
+    def self.load(root: Dir.pwd)
+      path = File.join(root, CONFIG_PATH)
+      data = File.exist?(path) ? JSON.parse(File.read(path)) : {}
+      new(data)
+    end
+
+    class EntryPoints
+      attr_reader :js, :css
+
+      def initialize(data = {})
+        @js = data.fetch('js', %w[app/assets/js/app.js])
+        @css = data.fetch('css', %w[app/assets/css/app.css])
+      end
+    end
+
+    class DevServer
+      attr_reader :host, :port
+
+      def initialize(data = {})
+        @host = data.fetch('host', '127.0.0.1')
+        @port = data.fetch('port', 3002)
+        @secure = data.fetch('secure', false)
+      end
+
+      def secure?
+        @secure
+      end
+
+      def ws_protocol
+        secure? ? 'wss' : 'ws'
+      end
+
+      def ws_url
+        "#{ws_protocol}://#{host}:#{port}"
+      end
+    end
+  end
+end

data/lib/bun_bun_bundle/dev_cache_middleware.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module BunBunBundle
+  # Rack middleware that sets no-cache headers on asset requests in development.
+  #
+  # This ensures the browser always fetches fresh assets during development,
+  # avoiding stale-cache issues when files are rebuilt.
+  #
+  # Usage:
+  #
+  #   # In Rails:
+  #   # Automatically added by the Railtie in development.
+  #
+  #   # In Hanami:
+  #   # Automatically added by the Hanami integration in development.
+  #
+  #   # Manual Rack usage:
+  #   use BunBunBundle::DevCacheMiddleware
+  #
+  class DevCacheMiddleware
+    ASSET_EXTENSIONS = %w[
+      .js .css .map .json
+      .png .jpg .jpeg .gif .svg .webp
+      .woff .woff2 .ttf .eot
+    ].freeze
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      status, headers, body = @app.call(env)
+
+      if asset_request?(env['PATH_INFO'])
+        headers['Cache-Control'] = 'no-store, no-cache, must-revalidate'
+        headers['Expires'] = '0'
+      end
+
+      [status, headers, body]
+    end
+
+    private
+
+    def asset_request?(path)
+      return false unless path
+
+      ASSET_EXTENSIONS.any? { |ext| path.end_with?(ext) }
+    end
+  end
+end

data/lib/bun_bun_bundle/hanami.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module BunBunBundle
+  # Hanami integration for BunBunBundle.
+  #
+  # Add to your Hanami app's config/app.rb:
+  #
+  #   require "bun_bun_bundle/hanami"
+  #
+  #   module MyApp
+  #     class App < Hanami::App
+  #       config.middleware.use BunBunBundle::DevCacheMiddleware if Hanami.env?(:development)
+  #     end
+  #   end
+  #
+  # Then include helpers in your views:
+  #
+  #   # app/views/helpers.rb
+  #   module MyApp
+  #     module Views
+  #       module Helpers
+  #         include BunBunBundle::Helpers
+  #         include BunBunBundle::ReloadTag
+  #       end
+  #     end
+  #   end
+  #
+  module HanamiIntegration
+    def self.setup(root: Dir.pwd)
+      BunBunBundle.config = Config.load(root: root)
+
+      BunBunBundle.manifest = if BunBunBundle.development?
+                                Manifest.load(root: root)
+                              else
+                                Manifest.load(root: root, retries: 1, delay: 0)
+                              end
+    end
+  end
+end
+
+# Auto-setup when loaded in a Hanami app.
+if defined?(Hanami)
+  Hanami::App.after :configure do
+    BunBunBundle::HanamiIntegration.setup(root: root.to_s)
+  end
+end

data/lib/bun_bun_bundle/helpers.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module BunBunBundle
+  # Asset helpers for use in views/templates.
+  #
+  # Include this module in your view helpers to get access to `bun_asset` and
+  # tag helpers. Works with ERB, Haml, Slim, or any other templating engine.
+  #
+  # Example (ERB):
+  #
+  #   <img src="<%= bun_asset("images/logo.png") %>">
+  #   <%= bun_js_tag("js/app.js") %>
+  #   <%= bun_css_tag("css/app.css") %>
+  #
+  module Helpers
+    # Returns the public path to an asset from the manifest.
+    #
+    # Prepends the configured public_path and asset_host:
+    #
+    #   bun_asset("js/app.js")       # => "/assets/js/app.js"
+    #   bun_asset("images/logo.png") # => "/assets/images/logo-abc123.png" (production)
+    #
+    def bun_asset(path)
+      fingerprinted = BunBunBundle.manifest[path]
+      "#{BunBunBundle.asset_host}#{BunBunBundle.config.public_path}/#{fingerprinted}"
+    end
+
+    # Generates a <script> tag for a JS entry point.
+    #
+    #   bun_js_tag("js/app.js")
+    #   # => '<script src="/assets/js/app.js" type="text/javascript"></script>'
+    #
+    def bun_js_tag(source, **options)
+      src = bun_asset(source)
+      attrs = { type: 'text/javascript' }.merge(options).merge(src: src)
+      %(<script #{_bun_html_attrs(attrs)}></script>)
+    end
+
+    # Generates a <link> tag for a CSS entry point.
+    #
+    #   bun_css_tag("css/app.css")
+    #   # => '<link href="/assets/css/app.css" type="text/css" rel="stylesheet">'
+    #
+    def bun_css_tag(source, **options)
+      href = bun_asset(source)
+      attrs = { type: 'text/css', rel: 'stylesheet' }.merge(options).merge(href: href)
+      %(<link #{_bun_html_attrs(attrs)}>)
+    end
+
+    # Generates an <img> tag for an image asset.
+    #
+    #   bun_img_tag("images/logo.png", alt: "Logo")
+    #   # => '<img src="/assets/images/logo.png" alt="Logo">'
+    #
+    def bun_img_tag(source, **options)
+      src = bun_asset(source)
+      alt = options.delete(:alt) || File.basename(source, '.*').tr('-_', ' ').capitalize
+      attrs = { alt: alt }.merge(options).merge(src: src)
+      %(<img #{_bun_html_attrs(attrs)}>)
+    end
+
+    private
+
+    def _bun_html_attrs(hash)
+      hash.compact.map do |k, v|
+        v == true ? k.to_s : %(#{k}="#{_bun_escape_attr(v)}")
+      end.join(' ')
+    end
+
+    def _bun_escape_attr(value)
+      value.to_s.gsub('&', '&amp;').gsub('"', '&quot;').gsub('<', '&lt;').gsub('>', '&gt;')
+    end
+  end
+end

data/lib/bun_bun_bundle/manifest.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module BunBunBundle
+  class Manifest
+    class MissingAssetError < StandardError; end
+
+    attr_reader :entries
+
+    def initialize(entries = {})
+      @entries = entries.freeze
+    end
+
+    # Loads the manifest from a JSON file.
+    #
+    # Retries a configurable number of times to allow for the manifest to be
+    # built during boot (e.g. in development).
+    def self.load(path: nil, root: Dir.pwd, retries: 10, delay: 0.25)
+      path ||= BunBunBundle.config.manifest_path
+      full_path = File.expand_path(path, root)
+
+      retries.times do
+        if File.exist?(full_path)
+          data = JSON.parse(File.read(full_path))
+          return new(data)
+        end
+        sleep(delay)
+      end
+
+      raise "Manifest not found at #{full_path}. Run: bun_bun_bundle build"
+    end
+
+    def [](key)
+      entries.fetch(key) do
+        suggestion = find_similar(key)
+        message = "Asset not found: #{key}"
+        message += ". Did you mean: #{suggestion}?" if suggestion
+        raise MissingAssetError, message
+      end
+    end
+
+    def key?(key)
+      entries.key?(key)
+    end
+
+    def css_entry_points
+      entries.keys.select { |k| k.end_with?('.css') }
+    end
+
+    private
+
+    def find_similar(key, tolerance: 4)
+      entries.keys
+             .map { |k| [k, levenshtein(key, k)] }
+             .select { |_, d| d <= tolerance }
+             .min_by { |_, d| d }
+             &.first
+    end
+
+    def levenshtein(str_a, str_b) # rubocop:disable Metrics/AbcSize
+      return str_b.length if str_a.empty?
+      return str_a.length if str_b.empty?
+
+      distances = Array.new(str_a.length + 1) { |i| i }
+
+      (1..str_b.length).each do |j|
+        prev = distances[0]
+        distances[0] = j
+        (1..str_a.length).each do |i|
+          cost = str_a[i - 1] == str_b[j - 1] ? 0 : 1
+          temp = distances[i]
+          distances[i] = [distances[i] + 1, distances[i - 1] + 1, prev + cost].min
+          prev = temp
+        end
+      end
+
+      distances[str_a.length]
+    end
+  end
+end

data/lib/bun_bun_bundle/railtie.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'rails/railtie'
+
+module BunBunBundle
+  class Railtie < Rails::Railtie
+    initializer 'bun_bun_bundle.helpers' do
+      ActiveSupport.on_load(:action_view) do
+        include BunBunBundle::Helpers
+        include BunBunBundle::ReloadTag
+      end
+    end
+
+    initializer 'bun_bun_bundle.manifest' do |app|
+      config.after_initialize do
+        BunBunBundle.config = Config.load(root: app.root.to_s)
+
+        BunBunBundle.manifest = if BunBunBundle.development?
+                                  Manifest.load(root: app.root.to_s)
+                                else
+                                  Manifest.load(root: app.root.to_s, retries: 1, delay: 0)
+                                end
+      end
+    end
+
+    initializer 'bun_bun_bundle.dev_cache' do |app|
+      app.middleware.insert_before(0, BunBunBundle::DevCacheMiddleware) if BunBunBundle.development?
+    end
+  end
+end

data/lib/bun_bun_bundle/reload_tag.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module BunBunBundle
+  # Renders a live reload script tag for development.
+  #
+  # Connects to Bun's WebSocket dev server for:
+  # - CSS hot-reloading (without full page refresh)
+  # - Full page reload on JS/image changes
+  #
+  # Only outputs content when BunBunBundle.development? is true.
+  #
+  module ReloadTag
+    # Returns the live reload <script> tag, or an empty string in production.
+    #
+    # Example (ERB):
+    #
+    #   <%= bun_reload_tag %>
+    #
+    def bun_reload_tag # rubocop:disable Metrics/MethodLength
+      return '' unless BunBunBundle.development?
+
+      config = BunBunBundle.config
+      css_paths = BunBunBundle.manifest.css_entry_points.map do |key|
+        "#{config.public_path}/#{key}"
+      end
+
+      <<~HTML
+        <script>
+        (() => {
+          const cssPaths = #{css_paths.to_json};
+          const ws = new WebSocket('#{config.dev_server.ws_url}')
+
+          ws.onmessage = (event) => {
+            const data = JSON.parse(event.data)
+
+            if (data.type === 'css') {
+              document.querySelectorAll('link[rel="stylesheet"]').forEach(link => {
+                const linkPath = new URL(link.href).pathname.split('?')[0]
+                if (cssPaths.some(p => linkPath.startsWith(p))) {
+                  const url = new URL(link.href)
+                  url.searchParams.set('r', Date.now())
+                  link.href = url.toString()
+                }
+              })
+              console.log('\\u25b8 CSS reloaded')
+            } else if (data.type === 'error') {
+              console.error('\\u2716 Build error:', data.message)
+            } else {
+              console.log('\\u25b8 Reloading...')
+              location.reload()
+            }
+          }
+
+          ws.onopen = () => console.log('\\u25b8 Live reload connected')
+          ws.onclose = () => setTimeout(() => location.reload(), 2000)
+        })()
+        </script>
+      HTML
+    end
+  end
+end

data/lib/bun_bun_bundle/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module BunBunBundle
+  VERSION = '0.1.0'
+end

data/lib/bun_bun_bundle.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative 'bun_bun_bundle/version'
+require_relative 'bun_bun_bundle/config'
+require_relative 'bun_bun_bundle/manifest'
+require_relative 'bun_bun_bundle/helpers'
+require_relative 'bun_bun_bundle/reload_tag'
+require_relative 'bun_bun_bundle/dev_cache_middleware'
+
+module BunBunBundle
+  class << self
+    attr_writer :config, :manifest, :asset_host, :environment
+
+    def config
+      @config ||= Config.new
+    end
+
+    def manifest
+      @manifest ||= Manifest.new
+    end
+
+    def asset_host
+      @asset_host || ''
+    end
+
+    def environment
+      @environment || ENV['RACK_ENV'] || ENV['RAILS_ENV'] || 'development'
+    end
+
+    def development?
+      environment == 'development'
+    end
+
+    def production?
+      environment == 'production'
+    end
+
+    # Returns the path to the bundled JS files shipped with the gem.
+    def bun_path
+      File.expand_path('bun', __dir__)
+    end
+
+    # Resets all state. Useful for testing.
+    def reset!
+      @config = nil
+      @manifest = nil
+      @asset_host = nil
+      @environment = nil
+    end
+  end
+end
+
+require_relative 'bun_bun_bundle/railtie' if defined?(Rails::Railtie)

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: bun_bun_bundle
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Wout Fierens
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Zero-dependency asset bundler with CSS hot-reloading, fingerprinting,
+  live reload, and a flexible plugin system. Works with Rails, Hanami, or any Rack
+  app.
+executables:
+- bun_bun_bundle
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- exe/bun_bun_bundle
+- lib/bun/bake.js
+- lib/bun/bun_bundle.js
+- lib/bun/plugins/cssAliases.js
+- lib/bun/plugins/cssGlobs.js
+- lib/bun/plugins/index.js
+- lib/bun/plugins/jsGlobs.js
+- lib/bun_bun_bundle.rb
+- lib/bun_bun_bundle/config.rb
+- lib/bun_bun_bundle/dev_cache_middleware.rb
+- lib/bun_bun_bundle/hanami.rb
+- lib/bun_bun_bundle/helpers.rb
+- lib/bun_bun_bundle/manifest.rb
+- lib/bun_bun_bundle/railtie.rb
+- lib/bun_bun_bundle/reload_tag.rb
+- lib/bun_bun_bundle/version.rb
+homepage: https://codeberg.org/w0u7/bun_bun_bundle
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://codeberg.org/w0u7/bun_bun_bundle
+  source_code_uri: https://codeberg.org/w0u7/bun_bun_bundle
+  changelog_uri: https://codeberg.org/w0u7/bun_bun_bundle/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.9
+specification_version: 4
+summary: A self-contained asset bundler powered by Bun
+test_files: []