bridgetown-core 1.0.0.alpha8 → 1.0.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b0d6ef82d9ee9b28132bda459264d887de83f704a67277a0c9d4046a755e2508
-  data.tar.gz: d39e9bb5399b5d5d7167cc20a81d3ce89fff1626c7ec13847cc5042b48a802e7
+  metadata.gz: b6953f85017e90090c0078b710b3e447b69366bd9fed38bd5e307ee72ae3181c
+  data.tar.gz: 863dcdcea016110ae4e05922f7357b866bd2a77998b5da78ffb92819238c59c4
 SHA512:
-  metadata.gz: ff214944686584ddbc3ec0f853e60d233af3cc2d34a580141fe3771d76822770c6040429266b967133356588a01aec468b54fcd40d87cdffe844b1b307f48e85
-  data.tar.gz: d6028a5f062ae873bac66ff929315e884844aae412999180484316d774c5480849c854ea731f993419552693058ada6aeb2abef74c5176e98802acb6d1c5a274
+  metadata.gz: eb6a1aa56f1544fcc37c4e204df417b5d7d37fa0e219e6a484872cdf4defee1c165fda09f4f30486d64635ef9ab6cf6db3edc8c63316dd3e61ab37be1394443c
+  data.tar.gz: 81b03e750b6fe6b25c1fbb2e62350f2c2776bf4902c236c5299f90c653720037e74ae8500bf71d928825efd3d83c651ad1d80523cb1362a1db2100d8f88daef9

data/.rubocop.yml

@@ -11,6 +11,8 @@ AllCops:
     - vendor/**/*
     - tmp/**/*
     - test/source/**/*
+    - test/resources/src/_pages/*.rb
+    - lib/site_template/TEMPLATES/**/*
     - lib/site_template/Rakefile
     - lib/site_template/config.ru
     - lib/site_template/config/**/*
@@ -30,6 +32,10 @@ Performance/CollectionLiteralInLoop:
   Exclude:
     - test/test_filters.rb
 
+Style/OpenStructUse:
+  Exclude:
+    - test/**/*.rb
+
 Style/StringConcatenation:
   Exclude:
     - test/test_apply_command.rb

data/bin/bridgetown

@@ -19,12 +19,24 @@ Bridgetown::PluginManager.require_from_bundler
 # TODO: need to change behavior of Colorator gem
 ENV["THOR_SHELL"] = "Basic" if ENV["NO_COLOR"]
 
-output_version = if ARGV[0] == "-v"
+output_version = if ARGV[0] == "-v" || ARGV[0] == "--version"
                    puts "bridgetown #{Bridgetown::VERSION} \"#{Bridgetown::CODE_NAME}\""
                    true
                  end
 
+if env_index = ARGV.index { |arg| arg == "-e" } # rubocop:disable Lint/AssignmentInCondition
+  env = ARGV[env_index + 1]
+  ENV["BRIDGETOWN_ENV"] = env if env
+elsif env_flag = ARGV.find { |arg| arg.start_with?("--environment=") } # rubocop:disable Lint/AssignmentInCondition
+  ENV["BRIDGETOWN_ENV"] = env_flag.split("=").last
+end
+
 ENV["RACK_ENV"] = ENV["BRIDGETOWN_ENV"]
 
 require "bridgetown-core/commands/base"
-Bridgetown::Commands::Base.start unless output_version
+begin
+  Bridgetown::Commands::Base.start unless output_version
+rescue StandardError => e
+  Bridgetown::Errors.print_build_error(e)
+  exit(false)
+end

data/bridgetown-core.gemspec

@@ -30,27 +30,28 @@ Gem::Specification.new do |s|
 
   s.required_ruby_version     = ">= 2.7.0"
 
-  s.add_runtime_dependency("activemodel",           "~> 6.0")
-  s.add_runtime_dependency("activesupport",         "~> 6.0")
+  s.add_runtime_dependency("activemodel",           [">= 6.0", "< 8.0"])
+  s.add_runtime_dependency("activesupport",         [">= 6.0", "< 8.0"])
   s.add_runtime_dependency("addressable",           "~> 2.4")
   s.add_runtime_dependency("amazing_print",         "~> 1.2")
   s.add_runtime_dependency("colorator",             "~> 1.0")
   s.add_runtime_dependency("erubi",                 "~> 1.9")
   s.add_runtime_dependency("faraday",               "~> 1.0")
   s.add_runtime_dependency("faraday_middleware",    "~> 1.0")
-  s.add_runtime_dependency("hash_with_dot_access",  "~> 1.0")
+  s.add_runtime_dependency("hash_with_dot_access",  "~> 1.2")
   s.add_runtime_dependency("i18n",                  "~> 1.0")
   s.add_runtime_dependency("kramdown",              "~> 2.1")
   s.add_runtime_dependency("kramdown-parser-gfm",   "~> 1.0")
   s.add_runtime_dependency("liquid",                "~> 5.0")
-  s.add_runtime_dependency("liquid-component",      ">= 0.1")
   s.add_runtime_dependency("listen",                "~> 3.0")
   s.add_runtime_dependency("rack-indifferent",      ">= 1.2.0")
   s.add_runtime_dependency("rake",                  ">= 13.0")
   s.add_runtime_dependency("roda",                  "~> 3.46")
   s.add_runtime_dependency("rouge",                 "~> 3.0")
+  s.add_runtime_dependency("serbea",                "~> 1.0")
   s.add_runtime_dependency("terminal-table",        "~> 1.8")
   s.add_runtime_dependency("thor",                  "~> 1.1")
   s.add_runtime_dependency("tilt",                  "~> 2.0")
   s.add_runtime_dependency("webrick",               "~> 1.7")
+  s.add_runtime_dependency("zeitwerk",              "~> 2.5")
 end

data/lib/bridgetown-core/collection.rb

@@ -297,12 +297,6 @@ module Bridgetown
       resources << resource if site.config.unpublished || resource.published?
     end
 
-    private
-
-    def container
-      @container ||= site.config["collections_dir"]
-    end
-
     def sort_resources!
       if metadata["sort_by"].is_a?(String)
         sort_resources_by_key!
@@ -312,6 +306,12 @@ module Bridgetown
       resources.reverse! if metadata.sort_direction == "descending"
     end
 
+    private
+
+    def container
+      @container ||= site.config["collections_dir"]
+    end
+
     # A custom sort function based on Schwartzian transform
     # Refer https://byparker.com/blog/2017/schwartzian-transform-faster-sorting/ for details
     def sort_resources_by_key!

data/lib/bridgetown-core/commands/base.rb

@@ -34,41 +34,42 @@ module Bridgetown
           rake.display_tasks_and_comments
         end
 
-        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Style/GlobalVars
+        def load_rake_tasks(rake)
+          rake.load_rakefile
+          tasks = rake.instance_variable_get(:@tasks)
+          rake.instance_variable_set(:@tasks, tasks.reject do |_k, v|
+            v.locations.first&.include?("/lib/rails/tasks/") ||
+              v.locations.first&.include?("/lib/rake/dsl_definition")
+          end)
+        end
+
+        # rubocop:disable Style/GlobalVars
         def handle_no_command_error(cmd, _has_namespace = $thor_runner)
           require "rake"
           Rake::TaskManager.record_task_metadata = true
 
           Rake.with_application do |rake|
-            rake.instance_variable_set(:@name, "bridgetown")
             rake.standard_exception_handling do
               rakefile, _location = rake.find_rakefile_location
               unless rakefile
-                puts "No Rakefile found (searching: #{rake.class::DEFAULT_RAKEFILES.join(", ")})\n"
+                puts "No Rakefile found (searching: #{rake.class::DEFAULT_RAKEFILES.join(", ")})\n\n" # rubocop:disable Layout/LineLength
                 new.invoke("help")
                 return # rubocop:disable Lint/NonLocalExitFromIterator
               end
-              rake.load_rakefile
-              rake.top_level
-            end
-            cmd = cmd.split("[")
-            args = []
-            if cmd[1]
-              args = cmd[1].gsub("\\,", "__COMMA__").delete_suffix!("]").split(",").map do |item|
-                item.gsub("__COMMA__", ",")
-              end
+              rake.init("bridgetown")
+              load_rake_tasks(rake)
             end
 
-            if Rake::Task.task_defined?(cmd[0])
-              Rake::Task[cmd[0]].invoke(*args)
+            if Rake::Task.task_defined?(cmd.split("[")[0])
+              rake.top_level
             else
-              puts "Unknown task: #{cmd[0]}\n\nHere's a list of tasks you can run:"
+              puts "Unknown task: #{cmd.split("[")[0]}\n\nHere's a list of tasks you can run:"
               display_rake_tasks(rake)
             end
           end
         end
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Style/GlobalVars
+      # rubocop:enable Style/GlobalVars
 
       desc "dream", "There's a place where that idea still exists as a reality"
       def dream
@@ -101,8 +102,7 @@ module Bridgetown
               rakefile, _location = rake.find_rakefile_location
               return unless rakefile # rubocop:disable Lint/NonLocalExitFromIterator
 
-              rake.load_rakefile
-              rake.top_level
+              self.class.load_rake_tasks(rake)
               puts "Available Rake Tasks:"
               self.class.display_rake_tasks(rake)
             end

data/lib/bridgetown-core/commands/build.rb

@@ -77,7 +77,7 @@ module Bridgetown
         end
         Bridgetown.logger.info "Generating…"
         @site.process
-        Bridgetown.logger.info "Done! 🎉", "#{"Completed".green} in less than" \
+        Bridgetown.logger.info "Done! 🎉", "#{"Completed".bold.green} in less than" \
                                           " #{(Time.now - t).ceil(2)} seconds."
 
         return unless config_options[:using_puma]

data/lib/bridgetown-core/commands/clean.rb

@@ -21,12 +21,12 @@ module Bridgetown
         destination = config["destination"]
         metadata_file = File.join(config["root_dir"], ".bridgetown-metadata")
         cache_dir = File.join(config["root_dir"], config["cache_dir"])
-        webpack_dir = File.join(config["root_dir"], ".bridgetown-webpack")
+        bundling_dir = File.join(config["root_dir"], ".bridgetown-cache", "frontend-bundling")
 
         remove(destination, checker_func: :directory?)
         remove(metadata_file, checker_func: :file?)
         remove(cache_dir, checker_func: :directory?)
-        remove(webpack_dir, checker_func: :directory?)
+        remove(bundling_dir, checker_func: :directory?)
       end
 
       protected

data/lib/bridgetown-core/commands/concerns/configuration_overridable.rb

@@ -3,6 +3,13 @@
 module Bridgetown
   module Commands
     module ConfigurationOverridable
+      def self.included(klass)
+        desc = "The environment used for this command (aka development, test, production, etc.)"
+        klass.class_option :environment,
+                           aliases: "-e",
+                           desc: desc
+      end
+
       # Create a full Bridgetown configuration with the options passed in as overrides
       #
       # options - the configuration overrides

data/lib/bridgetown-core/commands/console.rb

@@ -1,6 +1,39 @@
 # frozen_string_literal: true
 
 module Bridgetown
+  module ConsoleMethods
+    def site
+      Bridgetown::Current.site
+    end
+
+    def collections
+      site.collections
+    end
+
+    def reload!
+      Bridgetown.logger.info "Reloading site..."
+
+      I18n.reload! # make sure any locale files get read again
+      Bridgetown::Hooks.trigger :site, :pre_reload, site
+      Bridgetown::Hooks.clear_reloadable_hooks
+      site.plugin_manager.reload_plugin_files
+      site.loaders_manager.reload_loaders
+      Bridgetown::Hooks.trigger :site, :post_reload, site
+
+      ConsoleMethods.site_reset(site)
+    end
+
+    def self.site_reset(site)
+      site.reset
+      Bridgetown.logger.info "Reading files..."
+      site.read
+      Bridgetown.logger.info "", "done!"
+      Bridgetown.logger.info "Running generators..."
+      site.generate
+      Bridgetown.logger.info "", "done!"
+    end
+  end
+
   module Commands
     class Console < Thor::Group
       extend Summarizable
@@ -37,24 +70,18 @@ module Bridgetown
         Bridgetown.logger.info "Environment:", Bridgetown.environment.cyan
         site = Bridgetown::Site.new(configuration_with_overrides(options))
 
-        unless options[:blank]
-          site.reset
-          Bridgetown.logger.info "Reading files..."
-          site.read
-          Bridgetown.logger.info "", "done!"
-          Bridgetown.logger.info "Running generators..."
-          site.generate
-          Bridgetown.logger.info "", "done!"
-        end
+        ConsoleMethods.site_reset(site) unless options[:blank]
 
-        $BRIDGETOWN_SITE = site
+        IRB::ExtendCommandBundle.include ConsoleMethods
         IRB.setup(nil)
         workspace = IRB::WorkSpace.new
         irb = IRB::Irb.new(workspace)
         IRB.conf[:IRB_RC]&.call(irb.context)
         IRB.conf[:MAIN_CONTEXT] = irb.context
-        eval("site = $BRIDGETOWN_SITE", workspace.binding, __FILE__, __LINE__)
-        Bridgetown.logger.info "Console:", "Now loaded as #{"site".cyan} variable."
+        Bridgetown.logger.info "Console:", "Your site is now available as #{"site".cyan}"
+        Bridgetown.logger.info "",
+                               "You can also access #{"collections".cyan} or perform a" \
+                               " #{"reload!".cyan}"
 
         trap("SIGINT") do
           irb.signal_handle

data/lib/bridgetown-core/commands/doctor.rb

@@ -57,8 +57,7 @@ module Bridgetown
       def conflicting_urls(site)
         conflicting_urls = false
         urls = {}
-        urls = collect_urls(urls, site.pages, site.dest)
-        urls = collect_urls(urls, site.collections.posts.docs, site.dest)
+        urls = collect_urls(urls, site.contents, site.dest)
         urls.each do |url, paths|
           next unless paths.size > 1
 
@@ -98,7 +97,11 @@ module Bridgetown
 
       def collect_urls(urls, things, destination)
         things.each do |thing|
-          dest = thing.destination(destination)
+          dest = if thing.method(:destination).arity == 1
+                   thing.destination(destination)
+                 else
+                   thing.destination
+                 end
           if urls[dest]
             urls[dest] << thing.path
           else
@@ -110,8 +113,8 @@ module Bridgetown
 
       def case_insensitive_urls(things, _destination)
         things.each_with_object({}) do |thing, memo|
-          dest = thing.destination.output_path
-          (memo[dest.downcase] ||= []) << dest
+          dest = thing.destination&.output_path
+          (memo[dest.downcase] ||= []) << dest if dest
         end
       end
 

data/lib/bridgetown-core/commands/esbuild/esbuild.config.js

@@ -0,0 +1,27 @@
+const build = require("./config/esbuild.defaults.js")
+
+// Update this if you need to configure a destination folder other than `output`
+const outputFolder = "output"
+
+// You can customize this as you wish, perhaps to add new esbuild plugins.
+//
+// Eg:
+//
+//  ```
+//  const path = require("path")
+//  const esbuildCopy = require('esbuild-plugin-copy').default
+//  const esbuildOptions = {
+//    plugins: [
+//      esbuildCopy({
+//        assets: {
+//          from: [path.resolve(__dirname, 'node_modules/somepackage/files/*')],
+//          to: [path.resolve(__dirname, 'output/_bridgetown/somepackage/files')],
+//        },
+//        verbose: false
+//      }),
+//    ]
+//  }
+//  ```
+const esbuildOptions = {}
+
+build(outputFolder, esbuildOptions)

data/lib/bridgetown-core/commands/esbuild/esbuild.defaults.js.erb

@@ -0,0 +1,216 @@
+// This file is created and managed by Bridgetown.
+// Instead of editing this file, add your overrides to `esbuild.config.js`
+//
+// To update this file to the latest version provided by Bridgetown,
+// run `bridgetown esbuild update`. Any changes to this file will be overwritten
+// when an update is applied hence we strongly recommend adding overrides to
+// `esbuild.config.js` instead of editing this file.
+//
+// Shipped with Bridgetown v<%= Bridgetown::VERSION %>
+
+const path = require("path")
+const fsLib = require("fs")
+const fs = fsLib.promises
+const glob = require("glob")
+const postcss = require("postcss")
+const postCssImport = require("postcss-import")
+const readCache = require("read-cache")
+
+// Glob plugin derived from:
+// https://github.com/thomaschaaf/esbuild-plugin-import-glob
+// https://github.com/xiaohui-zhangxh/jsbundling-rails/commit/b15025dcc20f664b2b0eb238915991afdbc7cb58
+const importGlobPlugin = () => ({
+  name: "import-glob",
+  setup: (build) => {
+    build.onResolve({ filter: /\*/ }, async (args) => {
+      if (args.resolveDir === "") {
+        return; // Ignore unresolvable paths
+      }
+
+      const adjustedPath = args.path.replace(/^bridgetownComponents\//, "../../src/_components/")
+
+      return {
+        path: adjustedPath,
+        namespace: "import-glob",
+        pluginData: {
+          path: adjustedPath,
+          resolveDir: args.resolveDir,
+        },
+      }
+    })
+
+    build.onLoad({ filter: /.*/, namespace: "import-glob" }, async (args) => {
+      const files = glob.sync(args.pluginData.path, {
+        cwd: args.pluginData.resolveDir,
+      }).sort()
+
+      const importerCode = `
+        ${files
+          .map((module, index) => `import * as module${index} from '${module}'`)
+          .join(';')}
+        const modules = {${files
+          .map((module, index) => `
+            "${module.replace("../../src/_components/", "")}": module${index},`)
+          .join("")}
+        };
+        export default modules;
+      `
+
+      return { contents: importerCode, resolveDir: args.pluginData.resolveDir }
+    })
+  },
+})
+
+const postCssPlugin = (options) => ({
+  name: "postcss",
+  async setup(build) {
+    // Process .css files with PostCSS
+    build.onLoad({ filter: /\.(css)$/ }, async (args) => {
+      const additionalFilePaths = []
+      const css = await fs.readFile(args.path, "utf8")
+
+      // Configure import plugin so PostCSS can properly resolve `@import`ed CSS files
+      const importPlugin = postCssImport({
+        filter: itemPath => {
+          // We'll want to track any imports later when in watch mode
+          additionalFilePaths.push(path.resolve(path.dirname(args.path), itemPath))
+          return true
+        },
+        load: async filename => {
+          let contents = await readCache(filename, "utf-8")
+          const filedir = path.dirname(filename)
+
+          // We need to transform `url(...)` in imported CSS so the filepaths are properly
+          // relative to the entrypoint. Seems icky to have to hack this! C'est la vie...
+          contents = contents.replace(/url\(['"]?\.\/(.*?)['"]?\)/g, (_match, p1) => {
+            const relpath = path.relative(args.path, path.resolve(filedir, p1)).replace(/^\.\.\//, "")
+            return `url("${relpath}")`
+          })
+          return contents
+        }
+      })
+
+      // Process the file through PostCSS
+      const result = await postcss([importPlugin, ...options.plugins]).process(css, {
+        map: true,
+        ...options.options,
+        from: args.path,
+      });
+
+      return {
+        contents: result.css,
+        loader: "css",
+        watchFiles: [args.path, ...additionalFilePaths],
+      }
+    })
+  },
+})
+
+// Set up defaults and generate frontend bundling manifest file
+const bridgetownPreset = (outputFolder) => ({
+  name: "bridgetownPreset",
+  async setup(build) {
+    // Ensure any imports anywhere starting with `/` are left verbatim
+    // so they can be used in-browser for actual `src` repo files
+    build.onResolve({ filter: /^\// }, args => {
+      return { path: args.path, external: true }
+    })
+
+    build.onStart(() => {
+      console.log("esbuild: frontend bundling started...")
+    })
+
+    // Generate the final output manifest
+    build.onEnd(async (result) => {
+      if (!result.metafile) {
+        console.warn("esbuild: build process error, cannot write manifest")
+        return
+      }
+
+      const manifest = {}
+      const entrypoints = []
+
+      // We don't need `frontend/` cluttering up everything
+      const stripPrefix = (str) => str.replace(/^frontend\//, "")
+
+      // For calculating the file size of bundle output
+      const fileSize = (path) => {
+        const { size } = fsLib.statSync(path)
+        const i = Math.floor(Math.log(size) / Math.log(1024))
+        return (size / Math.pow(1024, i)).toFixed(2) * 1 + ['B', 'KB', 'MB', 'GB', 'TB'][i]
+      }
+
+      // Let's loop through all the various outputs
+      for (const key in result.metafile.outputs) {
+        const value = result.metafile.outputs[key]
+        const inputs = Object.keys(value.inputs)
+        const pathShortener = new RegExp(`^${outputFolder}\\/_bridgetown\\/static\\/`, "g")
+        const outputPath = key.replace(pathShortener, "")
+
+        if (value.entryPoint) {
+          // We have an entrypoint!
+          manifest[stripPrefix(value.entryPoint)] = outputPath
+          entrypoints.push([outputPath, fileSize(key)])
+        } else if (key.match(/index(\.js)?\.[^-.]*\.css/) && inputs.find(item => item.endsWith("index.css"))) {
+          // Special treatment for index.css
+          manifest[stripPrefix(inputs.find(item => item.endsWith("index.css")))] = outputPath
+          entrypoints.push([outputPath, fileSize(key)])
+        } else if (inputs.length > 0) {
+          // Naive implementation, we'll just grab the first input and hope it's accurate
+          manifest[stripPrefix(inputs[0])] = outputPath
+        }
+      }
+
+      const manifestFolder = path.join(process.cwd(), ".bridgetown-cache", "frontend-bundling")
+      await fs.mkdir(manifestFolder, { recursive: true })
+      await fs.writeFile(path.join(manifestFolder, "manifest.json"), JSON.stringify(manifest))
+
+      console.log("esbuild: frontend bundling complete!")
+      console.log("esbuild: entrypoints processed:")
+      entrypoints.forEach(entrypoint => {
+        const [entrypointName, entrypointSize] = entrypoint
+        console.log(`         - ${entrypointName}: ${entrypointSize}`)
+      })
+    })
+  }
+})
+
+// Load the PostCSS config from postcss.config.js or whatever else is a supported location/format
+const postcssrc = require("postcss-load-config")
+const postCssConfig = postcssrc.sync()
+
+module.exports = (outputFolder, esbuildOptions) => {
+  esbuildOptions.plugins = esbuildOptions.plugins || []
+  // Add the PostCSS & glob plugins to the top of the plugin stack
+  esbuildOptions.plugins.unshift(postCssPlugin(postCssConfig))
+  esbuildOptions.plugins.unshift(importGlobPlugin())
+  // Add the Bridgetown preset to the bottom of the plugin stack
+  esbuildOptions.plugins.push(bridgetownPreset(outputFolder))
+
+  // esbuild, take it away!
+  require("esbuild").build({
+    bundle: true,
+    loader: {
+      ".jpg": "file",
+      ".png": "file",
+      ".gif": "file",
+      ".svg": "file",
+      ".woff": "file",
+      ".woff2": "file",
+      ".ttf": "file",
+      ".eot": "file",
+    },
+    resolveExtensions: [".tsx",".ts",".jsx",".js",".css",".json",".js.rb"],
+    nodePaths: ["frontend/javascript", "frontend/styles"],
+    watch: process.argv.includes("--watch"),
+    minify: process.argv.includes("--minify"),
+    sourcemap: true,
+    target: "es2016",
+    entryPoints: ["frontend/javascript/index.js"],
+    entryNames: "[dir]/[name].[hash]",
+    outdir: path.join(process.cwd(), `${outputFolder}/_bridgetown/static`),
+    publicPath: "/_bridgetown/static",
+    metafile: true,
+    ...esbuildOptions,
+  }).catch(() => process.exit(1))
+}

data/lib/bridgetown-core/commands/esbuild/migrate-from-webpack.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+# rubocop:disable Layout/LineLength
+
+if package_json["devDependencies"].key?("sass")
+  say "Unable to migrate, project uses Sass. Please migrate to PostCSS first before migrating to esbuild."
+  return
+end
+
+remove_file "webpack.config.js"
+remove_file "config/webpack.defaults.js"
+
+apply find_in_source_paths("setup.rb"), verbose: false
+
+default_postcss_config = File.expand_path("../../../site_template/postcss.config.js.erb", __dir__)
+template default_postcss_config, "postcss.config.js"
+
+unless Bridgetown.environment.test?
+  required_packages = %w(esbuild glob postcss postcss-flexbugs-fixes postcss-preset-env postcss-import postcss-load-config)
+  redundant_packages = %w(esbuild-loader webpack webpack-cli webpack-manifest-plugin webpack-merge css-loader file-loader mini-css-extract-plugin postcss-loader)
+
+  say "Installing required packages"
+
+  gsub_file "package.json", %r!    "postcss-focus-within": "^4.0.0",?!, ""
+
+  run "yarn add -D #{required_packages.join(" ")}"
+
+  packages_to_remove = package_json["devDependencies"].slice(*redundant_packages).keys
+  unless packages_to_remove.empty?
+    confirm = ask "\nThe following packages will be removed: \n\n#{packages_to_remove.join("\n")}\n\nWould you like to continue? [Yn]"
+    return unless confirm.casecmp?("Y")
+
+    run "yarn remove #{packages_to_remove.join(" ")}"
+  end
+end
+
+gsub_file "Rakefile", %(desc "Build the frontend with Webpack for deployment"), %(desc "Build the frontend with esbuild for deployment")
+gsub_file "Rakefile", %(desc "Watch the frontend with Webpack during development"), %(desc "Watch the frontend with esbuild during development")
+gsub_file "Rakefile", %(sh "yarn run webpack-build"), %(sh "yarn run esbuild")
+gsub_file "Rakefile", %(sh "yarn run webpack-dev --color"), %(sh "yarn run esbuild-dev")
+gsub_file "package.json", %("webpack-build": "webpack --mode production"), %("esbuild": "node esbuild.config.js --minify")
+gsub_file "package.json", %("webpack-dev": "webpack --mode development -w"), %("esbuild-dev": "node esbuild.config.js --watch")
+
+say "🎉 Migration steps to esbuild finished!"
+say "Make sure you replace your `webpack_path` helpers with `asset_path` helpers in your templates"
+
+# rubocop:enable Layout/LineLength

data/lib/bridgetown-core/commands/esbuild/setup.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+template "esbuild.defaults.js.erb", "config/esbuild.defaults.js"
+copy_file "esbuild.config.js", force: true

data/lib/bridgetown-core/commands/esbuild/update.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+template "esbuild.defaults.js.erb", "config/esbuild.defaults.js", force: true
+say "🎉 esbuild configuration updated successfully!"