proscenium 0.19.0.beta4-arm64-darwin → 0.19.0.beta6-arm64-darwin

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 30f6dd1ec92c5a7dd53df353c65757e18ec374d0d1eaf407364d9baaed60d2a6
-  data.tar.gz: 2aeea6b5c6940af2521afd786db4289ee137c2813f6860ed7c8a880f89d3d6c1
+  metadata.gz: f3c6d979009796ee291585c2e5c229c6ad894b7861ed0e6771b2376dee0b29be
+  data.tar.gz: be6f8c87c387225c306142e09bb517a47e4b31d0a70e4973c3710d1ca6a8c0d2
 SHA512:
-  metadata.gz: cdb6490ba1a47a9c620a16bf8e5b9d8396e552121645cdace3778a8b6a9936fe310cd9881d5c2be1f7b5cdfc1047b963d146b1f72e772e5e99c9e2c70cf09f50
-  data.tar.gz: 7355f6c13d8aea2c56c6eba5e848b436274e56e29621b46a0c15e63c1b5a116cbaae268fda699d94da650d7a346acf58e9c4c7b58f520b3d3b0ad731aa0a4421
+  metadata.gz: d12060a40b22e1353cff66cf276c9caf4963153e4b315530a4bc768a72188299bef188b0c0ff9a706ded739fe407a7014a96a42ba00bfe0297492ea2262406ba
+  data.tar.gz: b4ef71bae7c0f66dfeb3873b3fe8c3d544a70bad29cd76d591a32aa6e6d2aecad81222a6f61c2e889b79226c2c761aaac3ff50540c17dd8b089af9bb6d6fffed

data/README.md

@@ -413,7 +413,7 @@ if (typeof proscenium.env?.UNKNOWN !== "undefined") {
 Basic support is provided for importing your Rails locale files from `config/locales/*.yml`, exporting them as JSON.
 
 ```js
-import translations from "@proscenium/i18n";
+import translations from "proscenium/i18n";
 // translations.en.*
 ```
 

data/lib/proscenium/builder.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'ffi'
-require 'oj'
 
 module Proscenium
   class Builder
@@ -42,7 +41,7 @@ module Proscenium
       attr_reader :error
 
       def initialize(error)
-        @error = Oj.load(error, mode: :strict).deep_transform_keys(&:underscore)
+        @error = JSON.parse(error, strict: true).deep_transform_keys(&:underscore)
 
         msg = @error['text']
         if (location = @error['location'])
@@ -65,8 +64,8 @@ module Proscenium
       new(root:).build_to_path(path)
     end
 
-    def self.build_to_string(path, root: nil)
-      new(root:).build_to_string(path)
+    def self.build_to_string(path, root: nil, bundle: nil)
+      new(root:, bundle:).build_to_string(path)
     end
 
     def self.resolve(path, root: nil)
@@ -78,15 +77,18 @@ module Proscenium
       Request.reset_config
     end
 
-    def initialize(root: nil)
+    def initialize(root: nil, bundle: nil)
+      bundle = Proscenium.config.bundle if bundle.nil?
+
       @request_config = FFI::MemoryPointer.from_string({
         RootPath: (root || Rails.root).to_s,
         GemPath: gem_root,
         Environment: ENVIRONMENTS.fetch(Rails.env.to_sym, 2),
-        Engines: engines,
+        Engines: Proscenium.config.engines,
         EnvVars: env_vars,
         CodeSplitting: Proscenium.config.code_splitting,
-        Bundle: Proscenium.config.bundle,
+        ExternalNodeModules: Proscenium.config.external_node_modules,
+        Bundle: bundle,
         Debug: Proscenium.config.debug
       }.to_json)
     end
@@ -139,12 +141,6 @@ module Proscenium
       q ? "--cache-query-string #{q}" : nil
     end
 
-    def engines
-      Proscenium.config.engines.to_h { |e| [e.engine_name, e.root.to_s] }.tap do |x|
-        x['proscenium/ui'] = Proscenium.ui_path.to_s
-      end
-    end
-
     def gem_root
       Pathname.new(__dir__).join('..', '..').to_s
     end

data/lib/proscenium/importer.rb

@@ -67,28 +67,28 @@ module Proscenium
         sideload_css(filepath, **options) unless options[:css] == false
       end
 
-      def sideload_js(filepath, **options)
-        return unless Proscenium.config.side_load
-
-        filepath = Rails.root.join(filepath) unless filepath.is_a?(Pathname)
-        filepath = filepath.sub_ext('')
+      def sideload_js(filepath, **)
+        _sideload(filepath, JS_EXTENSIONS, **)
+      end
 
-        JS_EXTENSIONS.find do |x|
-          if (fp = filepath.sub_ext(x)).exist?
-            import(Resolver.resolve(fp.to_s), sideloaded: true, **options)
-          end
-        end
+      def sideload_css(filepath, **)
+        _sideload(filepath, CSS_EXTENSIONS, **)
       end
 
-      def sideload_css(filepath, **options)
+      private def _sideload(filepath, extensions, **options) # rubocop:disable Style/AccessModifierDeclarations
         return unless Proscenium.config.side_load
 
         filepath = Rails.root.join(filepath) unless filepath.is_a?(Pathname)
         filepath = filepath.sub_ext('')
 
-        CSS_EXTENSIONS.find do |x|
+        extensions.find do |x|
           if (fp = filepath.sub_ext(x)).exist?
-            import(Resolver.resolve(fp.to_s), sideloaded: true, **options)
+            if (fp = fp.to_s).start_with?(Proscenium.ui_path.to_s)
+              fp.sub!(Proscenium.ui_path_regex, 'proscenium/')
+              import(Resolver.resolve(fp), sideloaded: true, **options)
+            else
+              import(Resolver.resolve(fp.to_s), sideloaded: true, **options)
+            end
           end
         end
       end

data/lib/proscenium/middleware/base.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'oj'
-
 module Proscenium
   class Middleware
     class Base
@@ -90,6 +88,11 @@ module Proscenium
           response.cache! Proscenium.config.cache_max_age
         end
 
+        cache_proc = Proscenium.config.cache_middleware_response
+        if cache_proc.is_a?(Proc) && cache_proc.call(path_to_build)
+          response.cache! Proscenium.config.cache_max_age
+        end
+
         yield response if block_given?
 
         response.finish

data/lib/proscenium/middleware/engines.rb

@@ -10,7 +10,7 @@ module Proscenium
     #
     #   module Gem1
     #     class Engine < ::Rails::Engine
-    #       config.proscenium.engines << self
+    #       config.proscenium.engines['gem1'] = root
     #     end
     #   end
     #
@@ -24,21 +24,17 @@ module Proscenium
       end
 
       def root_for_readable
-        ui? ? Proscenium.ui_path : engine.root
+        engine.last
       end
 
       def engine
-        @engine ||= Proscenium.config.engines.find do |x|
-          @request.path.start_with?("/#{x.engine_name}")
+        @engine ||= Proscenium.config.engines.find do |k, _|
+          @request.path.start_with?("/#{k}")
         end
       end
 
       def engine_name
-        ui? ? 'proscenium/ui' : engine.engine_name
-      end
-
-      def ui?
-        @request.path.start_with?('/proscenium/ui/')
+        engine.first
       end
     end
   end

data/lib/proscenium/middleware/esbuild.rb

@@ -6,21 +6,26 @@ module Proscenium
       class CompileError < Base::CompileError
         def initialize(args)
           detail = args[:detail]
-          detail = ActiveSupport::HashWithIndifferentAccess.new(Oj.load(detail, mode: :strict))
+          detail = JSON.parse(detail, mode: :strict)
 
-          args[:detail] = if detail[:location]
-                            "#{detail[:text]} in #{detail[:location][:file]}:" +
-                              detail[:location][:line].to_s
-                          else
-                            detail[:text]
-                          end
+          args['detail'] = if detail['location']
+                             "#{detail['text']} in #{detail['location']['file']}:" +
+                               detail['location']['line'].to_s
+                           else
+                             detail['text']
+                           end
 
           super
         end
       end
 
       def attempt
-        render_response Builder.build_to_string(path_to_build)
+        bundle = nil
+        if Proscenium.config.external_node_modules && path_to_build.start_with?('node_modules/')
+          bundle = false
+        end
+
+        render_response Builder.build_to_string(path_to_build, bundle:)
       rescue Builder::CompileError => e
         raise self.class::CompileError, { file: @request.fullpath, detail: e.message }, caller
       end

data/lib/proscenium/middleware.rb

@@ -10,7 +10,6 @@ module Proscenium
     autoload :Base
     autoload :Esbuild
     autoload :Engines
-    autoload :Runtime
 
     def initialize(app)
       @app = app
@@ -40,7 +39,6 @@ module Proscenium
     end
 
     def find_type(request)
-      return Runtime if request.path.match?(%r{^/@proscenium/})
       return Esbuild if Pathname.new(request.path).fnmatch?(app_path_glob, File::FNM_EXTGLOB)
 
       pathname = Pathname.new(request.path)
@@ -53,12 +51,12 @@ module Proscenium
     end
 
     def engines_path_glob
-      names = Proscenium.config.engines.map(&:engine_name)
+      names = Proscenium.config.engines.keys
       "/{#{names.join(',')}}/{#{Proscenium::ALLOWED_DIRECTORIES}}/**.{#{file_extensions}}"
     end
 
     def ui_path_glob
-      "/proscenium/ui/**.{#{file_extensions}}"
+      "/proscenium/**.{#{file_extensions}}"
     end
 
     def file_extensions

data/lib/proscenium/railtie.rb

@@ -14,6 +14,7 @@ module Proscenium
     config.proscenium.bundle = true
     config.proscenium.side_load = true
     config.proscenium.code_splitting = true
+    config.proscenium.external_node_modules = false
 
     # Cache asset paths when building to path. Enabled by default in production.
     # @see Proscenium::Builder#build_to_path
@@ -23,6 +24,13 @@ module Proscenium
     config.proscenium.cache_query_string = Rails.env.production? && ENV.fetch('REVISION', nil)
     config.proscenium.cache_max_age = 2_592_000 # 30 days
 
+    # A proc that will be given the path to build, and should return a boolean indicating whether to
+    # cache the response.
+    #
+    # Example:
+    #   cache_middleware_response = ->(path) { path.start_with?('node_modules/') }
+    config.proscenium.cache_middleware_response = nil
+
     # List of environment variable names that should be passed to the builder, which will then be
     # passed to esbuild's `Define` option. Being explicit about which environment variables are
     # defined means a faster build, as esbuild will have less to do.
@@ -36,9 +44,11 @@ module Proscenium
     #
     # Example:
     #   class Gem1::Engine < ::Rails::Engine
-    #     config.proscenium.engines << self
+    #     config.proscenium.engines[:gem1] = root
     #   end
-    config.proscenium.engines = Set.new
+    config.proscenium.engines = {
+      proscenium: Proscenium.ui_path
+    }
 
     config.action_dispatch.rescue_templates = {
       'Proscenium::Builder::BuildError' => 'build_error'
@@ -64,9 +74,9 @@ module Proscenium
     end
 
     initializer 'proscenium.middleware' do |app|
-      app.middleware.insert_after ActionDispatch::Static, Middleware
-      app.middleware.insert_after ActionDispatch::Static, Rack::ETag, 'no-cache'
-      app.middleware.insert_after ActionDispatch::Static, Rack::ConditionalGet
+      app.middleware.insert_after ActionDispatch::Static, Proscenium::Middleware
+      # app.middleware.insert_after ActionDispatch::Static, Rack::ETag, 'no-cache'
+      # app.middleware.insert_after ActionDispatch::Static, Rack::ConditionalGet
     end
 
     initializer 'proscenium.sideloading' do

data/lib/proscenium/react_componentable.rb

@@ -40,7 +40,7 @@ module Proscenium
       class_attribute :loader
 
       # @return [String] the URL path to the component manager.
-      class_attribute :manager, default: '/@proscenium/react-manager/index.jsx'
+      class_attribute :manager, default: '/proscenium/react-manager/index.jsx'
     end
 
     class_methods do

data/lib/proscenium/resolver.rb

@@ -11,8 +11,6 @@ module Proscenium
     #
     # @param path [String] Can be URL path, file system path, or bare specifier (ie. NPM package).
     # @return [String] URL path.
-    #
-    # rubocop:disable Metrics/*
     def self.resolve(path)
       self.resolved ||= {}
 
@@ -21,12 +19,10 @@ module Proscenium
           raise ArgumentError, 'path must be an absolute file system or URL path'
         end
 
-        if path.start_with?('@proscenium/')
+        if path.start_with?('proscenium/')
           "/#{path}"
-        elsif path.start_with?(Proscenium.ui_path.to_s)
-          path.delete_prefix Proscenium.root.join('lib').to_s
-        elsif (engine = Proscenium.config.engines.find { |e| path.start_with? "#{e.root}/" })
-          path.sub(/^#{engine.root}/, "/#{engine.engine_name}")
+        elsif (engine = Proscenium.config.engines.find { |_, v| path.start_with? "#{v}/" })
+          path.sub(/^#{engine.last}/, "/#{engine.first}")
         elsif path.start_with?("#{Rails.root}/")
           path.delete_prefix Rails.root.to_s
         else
@@ -34,6 +30,5 @@ module Proscenium
         end
       end
     end
-    # rubocop:enable Metrics/*
   end
 end

data/lib/proscenium/side_load.rb

@@ -172,7 +172,7 @@ module Proscenium
         end
 
         # The reason why we sideload CSS after JS is because the order of CSS is important.
-        # Basically, the layout should be loaded before the view so that CSS cascading works i9n the
+        # Basically, the layout should be loaded before the view so that CSS cascading works in the
         # right direction.
         css_imports.reverse_each do |it|
           Importer.sideload_css it, **options

data/lib/proscenium/ui/flash/index.css

@@ -0,0 +1 @@
+@import "https://cdn.jsdelivr.net/npm/sourdough-toast/src/sourdough-toast.css";

data/lib/proscenium/ui/flash/index.js

@@ -0,0 +1,73 @@
+import domMutations from "https://esm.run/dom-mutations";
+import { Sourdough, toast } from "https://esm.run/sourdough-toast";
+
+class HueFlash extends HTMLElement {
+  static observedAttributes = ["data-flash-alert", "data-flash-notice"];
+
+  connectedCallback() {
+    this.#initSourdough();
+  }
+
+  async #initSourdough() {
+    if ("sourdoughBooted" in window) return;
+
+    const sourdough = new Sourdough({
+      richColors: true,
+      yPosition: "bottom",
+      xPosition: "center",
+    });
+    sourdough.boot();
+    window.sourdoughBooted = true;
+
+    // Watch for changes to htl:flashes meta tag
+    const flashesSelector = "meta[name='rails:flashes']";
+    for await (const mutation of domMutations(document.head, {
+      childList: true,
+      subtree: true,
+      attributes: true,
+    })) {
+      let $ele = null;
+
+      if (
+        mutation.type === "attributes" &&
+        mutation.target.nodeName == "META" &&
+        mutation.attributeName == "content"
+      ) {
+        $ele = mutation.target;
+      } else if (mutation.type === "childList") {
+        for (const node of mutation.addedNodes) {
+          if (node.matches(flashesSelector)) {
+            $ele = node;
+            break;
+          }
+        }
+      }
+
+      if ($ele) {
+        const flashes = JSON.parse($ele.getAttribute("content"));
+        for (const [type, message] of Object.entries(flashes)) {
+          if (type === "alert") {
+            toast.error(message);
+          } else if (type === "notice") {
+            toast.success(message);
+          }
+        }
+      }
+    }
+  }
+
+  attributeChangedCallback(name, _oldValue, newValue) {
+    this.#initSourdough();
+
+    if (newValue === null) return;
+
+    if (name === "data-flash-alert") {
+      toast.warning(newValue);
+    } else if (name === "data-flash-notice") {
+      toast.success(newValue);
+    }
+  }
+}
+
+!customElements.get("pui-flash") &&
+  customElements.define("pui-flash", HueFlash);

data/lib/proscenium/ui/flash.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Proscenium::UI
+  class Flash < Component
+    register_element :pui_flash
+
+    def self.source_path
+      super / '../flash/index.rb'
+    end
+
+    def view_template
+      pui_flash data: { flash: helpers.flash.to_hash }
+    end
+  end
+end

data/lib/proscenium/ui/form/field_methods.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+class Proscenium::UI::Form
+  module FieldMethods
+    # Renders a hidden input field.
+    #
+    # @param args [Array<Symbol>] name or nested names of model attribute
+    # @param attributes [Hash] passed through to each input
+    def hidden_field(*args, **)
+      render Fields::Hidden.new(args, @model, self, **)
+    end
+
+    # @param args [Array<Symbol>] name or nested names of model attribute
+    # @param attributes [Hash] passed through to each input
+    def rich_textarea_field(*args, **attributes)
+      merge_bang_attributes! args, attributes
+      render Fields::RichTextarea.new(args, @model, self, **attributes)
+    end
+
+    # @param args [Array<Symbol>] name or nested names of model attribute
+    # @param attributes [Hash] passed through to each input
+    def datetime_local_field(*args, **attributes)
+      merge_bang_attributes! args, attributes
+      render Fields::Datetime.new(args, @model, self, **attributes)
+    end
+
+    # @param args [Array<Symbol>] name or nested names of model attribute
+    # @param attributes [Hash] passed through to each input
+    def checkbox_field(*args, **attributes)
+      merge_bang_attributes! args, attributes
+      render Fields::Checkbox.new(args, @model, self, **attributes)
+    end
+
+    # @param args [Array<Symbol>] name or nested names of model attribute
+    # @param attributes [Hash] passed through to each input
+    def tel_field(*args, **attributes)
+      merge_bang_attributes! args, attributes
+      render Fields::Tel.new(args, @model, self, **attributes)
+    end
+
+    # @param args [Array<Symbol>] name or nested names of model attribute
+    # @param attributes [Hash] passed through to each input
+    def select_field(*args, **attributes, &)
+      merge_bang_attributes! args, attributes, additional_bang_attrs: [:typeahead]
+      render Fields::Select.new(args, @model, self, **attributes, &)
+    end
+
+    # @see #select_field
+    def select_country_field(*args, **attributes)
+      merge_bang_attributes! args, attributes
+      attributes[:typeahead] = true
+      attributes[:options] = '/countries'
+      attributes[:component_props] = {
+        items_on_search: true,
+        input_props: { required: attributes.delete(:required) }
+      }
+
+      select_field(*args, **attributes)
+    end
+
+    # Renders a <textarea> field for the given `attribute`.
+    #
+    # @param args [Array<Symbol>] name or nested names of model attribute
+    # @param attributes [Hash] passed through to each input
+    def textarea_field(*args, **attributes)
+      merge_bang_attributes! args, attributes
+      render Fields::Textarea.new(args, @model, self, **attributes)
+    end
+
+    # Renders a group of radio inputs for each option of the given `field`.
+    #
+    # @param args [Array<Symbol>] name or nested names of model attribute
+    # @param attributes [Hash] passed through to each input
+    def radio_group(*args, **attributes)
+      attributes[:options] = args.pop if args.last.is_a?(Array)
+
+      render Fields::RadioGroup.new(args, @model, self, **attributes)
+    end
+
+    def radio_field(...)
+      div { radio_input(...) }
+    end
+
+    def radio_input(*args, **)
+      render Fields::RadioInput.new(args, @model, self, **)
+    end
+  end
+end