svelte-on-rails 8.1.0 → 9.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8888526927853e78465bc1bbda518d82a0a499c33a1d99d5ada3ea411c0baf70
-  data.tar.gz: 0c019007e8d68e48e659a47041a15af833d7bd1c1a8b0414af8a51d836a2397d
+  metadata.gz: c7247500d2d0c44d3c91cf1bfa5aec7861ec4306928fdfecbcc42e79fda5e63a
+  data.tar.gz: 5668e8ec34a3d12fb794641fc763162aa11b1ba2611f4b6fd4145762f743e11e
 SHA512:
-  metadata.gz: 91f0eb2d62372a9a7b2337adbb209c6db8f0eade705fe50d4a1fef516cb856999cfa3753521422cab4476399769e0c43672f79d716e839f19097ae4bfa0b273a
-  data.tar.gz: f7e4e9c10f8cdcbed1e56087fc2470b4c82f575bbf730bc816656dcf03c98becacf97c6efd98936e5696c1e1625d03a2234e251cd0bc9d197888cd72a8e07f88
+  metadata.gz: 806a37910e007388a2d89e10d370ca144e46180c78138d1eb7ee05852edec90fc43436f452c64d5901881eb77c1567c416406cff7ecb1e9102a4906a9ba56918
+  data.tar.gz: d2f5c37db64f31f061cca10132a4c2b1e70773e3377cce4502a411bcf23afbafad7e98809e9e2f08a933375a721df48a96dabbd12fd3b869dc0fbb88f2b6e41c

data/README.md

@@ -37,14 +37,16 @@ If you have issues, please open one, and contributors are welcome!
 ## Requirements
 
 - tested on
-    - ruby 3.2.2 and rails 7.1
-      - Recommended: ruby 3x
-    - ruby 2.7.5 and rails 6.1
-    - vite@6 (v7 not yet supported, see issues)
+    - ruby 3.4.2 / Rails 8.1.2
+    - ruby 3.2.2 / rails 7.1
+    - ruby 2.7.5 / rails 6.1
+    - vite@6 (v7 not yet tested, see issues)
     - turbolinks and hotwired/turbo
 - vite_rails (the installer will install it by option --full or --vite)
 - svelte@5, @sveltejs/vite-plugin-svelte@5 (see: [how to install svelte on rails/vite](https://dev.to/chmich/setup-inertia-and-svelte-on-rails-7-3glk))
+  - since gem-version 9, svelte runes-mode is set to true for ssr, check svelte-5 migration guide
 - turbo (recommended / [how to install turbo on rails](https://github.com/hotwired/turbo-rails?tab=readme-ov-file#installation))
+  - this is because of using ssr for initial-load only but that feature is also available for turbo-links.
 - npm on latest versions
 - actual node installed.
     - if `nvm` is installed it gets the path to the node-binary from there.

data/lib/generators/showcase_generator.rb

@@ -0,0 +1,128 @@
+require "rails/generators"
+
+module SvelteOnRails
+  module Generators
+    class ShowcaseGenerator < Rails::Generators::Base
+
+      class_option :full, type: :boolean, default: false, desc: "Run full installation with additional setup"
+      class_option :force, type: :boolean, default: false, desc: "Do not ask for overwriting files"
+      class_option :turbo, type: :boolean, default: false, desc: "Use @hotwired/turbo-rails"
+      class_option :turbo_streams, type: :boolean, default: false, desc: "Turbo::StreamsChannel"
+      class_option :hello_world, type: :boolean, default: false, desc: "Create Hello World component"
+
+      require 'svelte_on_rails/installer/utils'
+      require 'svelte_on_rails/installer/haml'
+      require 'svelte_on_rails/lib/development_utils'
+
+      NPM_PACKAGE_NAME = '@csedl/svelte-on-rails'
+
+      def initialize(*args)
+
+        super
+
+        puts
+        puts '-' * 80
+        puts '-' * 80
+        puts 'INSTALLING DEMO COMPONENTS'
+        puts '-' * 80
+
+      end
+
+
+
+      def turbo
+
+        puts '-' * 80
+        puts ' ▶︎▶︎▶︎ INSTALLING @hotwired/turbo-rails'
+        puts '-' * 80
+        npm_i = SvelteOnRails::Installer::Npm
+        tr_pkg = '@hotwired/turbo-rails'
+        npm_i.install_or_update_package(tr_pkg)
+        js_i = SvelteOnRails::Installer::Javascript
+        js_i.append_import_statement(application_js_path, tr_pkg, "import '#{tr_pkg}';")
+
+        puts '-' * 80
+        puts ' ▶︎▶︎▶︎ INSTALLING Turbo::StreamsChannel'
+        puts '-' * 80
+
+        gem_uts = SvelteOnRails::GemUtils
+        puts '• installing turbo-rails ...'
+        gem_uts.install_gem('turbo-rails')
+        puts '• installed turbo-rails!'
+        utils_i = SvelteOnRails::Installer::Utils
+        puts '• running turbo:install ...'
+        utils_i.run_command('bundle exec rails turbo:install', success_message: 'You must import')
+        puts '• turbo:install finished!'
+      end
+
+
+
+
+      def hello_world
+
+        puts '-' * 80
+        puts ' ▶︎▶︎▶︎︎ INSTALLING Hello World component'
+        puts '-' * 80
+
+        hw_i = SvelteOnRails::Installer::HelloWorld
+
+        utils_i = SvelteOnRails::Installer::Utils
+        utils_i.add_route("  get \"svelte_on_rails_showcase/web_socket\"", app_root: Rails.root)
+        utils_i.add_route("  get \"svelte_on_rails_showcase/web_socket_action\"", app_root: Rails.root)
+        npm_i = SvelteOnRails::Installer::Npm
+        npm_i.install_or_update_package('axios')
+        npm_i.install_or_update_package('@rails/actioncable')
+        js_i = SvelteOnRails::Installer::Javascript
+        init_stat = '../initializers/actionCable.js'
+        js_i.append_import_statement(application_js_path, init_stat, "import '#{init_stat}';")
+        @hello_world_path = hw_i.install_hello_world(['showcase'], app_root: nil, force: true, silent: true)
+      end
+
+
+
+
+      def finish
+        puts '-' * 80
+
+        puts "SvelteOnRails Showcase installed successfully!"
+        puts "Restart the server and check if it all works."
+        if @hello_world_path
+          puts "You can now access the Hello World component on: http://localhost:your-port-number/svelte_on_rails_showcase."
+        end
+        puts "Happy coding!"
+      end
+
+      private
+
+      def toggle_hello_world_files
+        %w[
+          app/frontend/images/svg.svg
+          app/frontend/images/atom.svg
+          app/frontend/javascript/nestedJavascript.js
+          app/frontend/javascript/nestedJavascriptToggled.js
+        ]
+      end
+
+      # def validate_raw_options!(args)
+      #   # Get option names from class_options, excluding inherited Thor/Rails options
+      #   valid_options = self.class.class_options.keys.map { |opt| "--#{opt.to_s.tr('_', '-')}" }
+      #   rails_internal_options = %w[--skip-namespace --skip-collision-check --pretend --quiet --force]
+      #   options_array = args.find { |arg| arg.is_a?(Array) && arg.any? { |a| a.start_with?('--') } } || []
+      #   passed_options = options_array.select { |arg| arg.start_with?('--') }
+      #   unknown_options = passed_options - valid_options - rails_internal_options
+      #   unless unknown_options.empty?
+      #     valid_display = valid_options.map { |opt| opt.gsub(/^--/, '') }.join(', ')
+      #     raise Thor::Error, "Unknown options: #{unknown_options.join(', ')}. Valid options are: #{valid_display}\nNothing done."
+      #   end
+      #
+      #   if options[:turbo_streams] && !(options[:full] || options[:turbo])
+      #     raise Thor::Error, "--turbo-streams option cannot be used without --turbo"
+      #   end
+      # end
+
+      def application_js_path
+        Rails.root.join("app", "frontend", "entrypoints", "application.js")
+      end
+    end
+  end
+end

data/lib/generators/svelte_on_rails/install/install_generator.rb

@@ -6,12 +6,8 @@ module SvelteOnRails
 
       class_option :full, type: :boolean, default: false, desc: "Run full installation with additional setup"
       class_option :force, type: :boolean, default: false, desc: "Do not ask for overwriting files"
-      class_option :vite, type: :boolean, default: false, desc: "Use Vite"
-      class_option :haml, type: :boolean, default: false, desc: "Use Haml"
       class_option :turbo, type: :boolean, default: false, desc: "Use @hotwired/turbo-rails"
       class_option :turbo_streams, type: :boolean, default: false, desc: "Turbo::StreamsChannel"
-      class_option :svelte, type: :boolean, default: false, desc: "Install Svelte"
-      class_option :pug, type: :boolean, default: false, desc: "Install Pug"
       class_option :hello_world, type: :boolean, default: false, desc: "Create Hello World component"
 
       require 'svelte_on_rails/installer/utils'
@@ -24,29 +20,16 @@ module SvelteOnRails
 
         super
 
-        @local_npm_package_url = SvelteOnRails::DevelopmentUtils.local_npm_package_url
-
         puts
         validate_raw_options!(args)
         puts '-' * 80
         puts '-' * 80
         puts 'STARTING SVELTE-ON-RAILS INSTALLATION'
         puts "  • FORCED (option --force was given)" if options[:force]
-        if @local_npm_package_url
-          puts "  • Local Npm Package used: #{NPM_PACKAGE_NAME} used: #{@local_npm_package_url}"
-        end
         puts '-' * 80
 
       end
 
-      def vite
-        return unless options[:full] || options[:vite]
-        puts '-' * 80
-        puts '• INSTALLING VITE-RAILS'
-        vite_i = SvelteOnRails::Installer::Vite
-        vite_i.install_vite(version_specifier: '6')
-      end
-
       def svelte_on_rails
 
         puts '-' * 80
@@ -61,14 +44,7 @@ module SvelteOnRails
         pkg_js['scripts'] ||= { 'build:ssr': "vite build --config vite-ssr.config.ts" }
         File.write('package.json', JSON.pretty_generate(pkg_js))
 
-        if @local_npm_package_url
-          npm_i.link_local_package(NPM_PACKAGE_NAME, @local_npm_package_url)
-
-          # npm does not resolve peer dependencies on local package url
-          npm_i.install_or_update_package('@hotwired/stimulus')
-        else
-          npm_i.install_or_update_package(NPM_PACKAGE_NAME)
-        end
+        npm_i.install_or_update_package(NPM_PACKAGE_NAME)
         npm_i.install_or_update_package('typescript')
         npm_i.install_or_update_package('@types/node')
 
@@ -77,92 +53,6 @@ module SvelteOnRails
         js_i.append_import_statement(application_js_path, init_stat, "import '#{init_stat}';")
       end
 
-      def turbo
-        return unless options[:full] || options[:turbo]
-
-        puts '-' * 80
-        puts ' ▶︎▶︎▶︎ INSTALLING @hotwired/turbo-rails'
-        puts '-' * 80
-        npm_i = SvelteOnRails::Installer::Npm
-        tr_pkg = '@hotwired/turbo-rails'
-        npm_i.install_or_update_package(tr_pkg)
-        js_i = SvelteOnRails::Installer::Javascript
-        js_i.append_import_statement(application_js_path, tr_pkg, "import '#{tr_pkg}';")
-
-        return unless options[:turbo_streams] || options[:full]
-
-        puts '-' * 80
-        puts ' ▶︎▶︎▶︎ INSTALLING Turbo::StreamsChannel'
-        puts '-' * 80
-
-        gem_uts = SvelteOnRails::GemUtils
-        puts '• installing turbo-rails ...'
-        gem_uts.install_gem('turbo-rails')
-        puts '• installed turbo-rails!'
-        utils_i = SvelteOnRails::Installer::Utils
-        puts '• running turbo:install ...'
-        utils_i.run_command('bundle exec rails turbo:install', success_message: 'You must import')
-        puts '• turbo:install finished!'
-      end
-
-      def svelte
-        return unless options[:svelte] || options[:full]
-
-        puts '-' * 80
-        puts ' ▶︎▶︎▶︎ INSTALLING svelte (npm package)'
-
-        puts '-' * 80
-        svelte_i = SvelteOnRails::Installer::Svelte
-        svelte_i.install_svelte(
-          svelte_version_specifier: '5',
-          vite_plugin_svelte_version_specifier: '5'
-        )
-      end
-
-      def hello_world
-        return unless options[:hello_world] || options[:full]
-
-        puts '-' * 80
-        puts ' ▶︎▶︎▶︎︎ INSTALLING Hello World component'
-        puts '-' * 80
-
-        hw_i = SvelteOnRails::Installer::HelloWorld
-
-        utils_i = SvelteOnRails::Installer::Utils
-        utils_i.add_route("  get \"svelte_on_rails_hello_world/web_socket\"", app_root: Rails.root)
-        utils_i.add_route("  get \"svelte_on_rails_hello_world/web_socket_action\"", app_root: Rails.root)
-        npm_i = SvelteOnRails::Installer::Npm
-        npm_i.install_or_update_package('axios')
-        npm_i.install_or_update_package('@rails/actioncable')
-        js_i = SvelteOnRails::Installer::Javascript
-        init_stat = '../initializers/actionCable.js'
-        js_i.append_import_statement(application_js_path, init_stat, "import '#{init_stat}';")
-        @hello_world_path = hw_i.install_hello_world(['all_features_test'], app_root: nil, force: true, silent: true)
-      end
-
-      def haml_and_convert
-        return unless options[:haml]
-
-        puts '-' * 80
-        puts ' ▶︎▶︎▶︎ INSTALLING Haml and converting existing .erb files to .haml'
-
-        haml_i = SvelteOnRails::Installer::Haml
-        haml_i.install_haml_and_convert(force: options[:force])
-      end
-
-      def finish
-        puts '-' * 80
-        puts ' 👍  FINISHED SVELTE-ON-RAILS INSTALLATION 👍'
-        puts '-' * 80
-
-        puts "SvelteOnRails installed successfully!"
-        puts "Restart the server and check if it all works."
-        if @hello_world_path
-          puts "You can now access the Hello World component on: http://localhost:your-port-number#{@hello_world_path}."
-        end
-        puts "Happy coding!"
-      end
-
       private
 
       def toggle_hello_world_files

data/lib/svelte-on-rails.rb

@@ -16,13 +16,13 @@ require "svelte_on_rails/lib/to_svelte"
 require 'svelte_on_rails/installer/utils'
 require 'svelte_on_rails/installer/haml'
 require 'svelte_on_rails/installer/gem_utils'
-require 'svelte_on_rails/installer/vite'
 require 'svelte_on_rails/installer/svelte'
 require 'svelte_on_rails/installer/npm'
 require 'svelte_on_rails/installer/javascript'
 require 'svelte_on_rails/installer/hello_world'
 
 require 'generators/svelte_on_rails/install/install_generator'
+require 'generators/showcase_generator'
 
 module SvelteOnRails
   class << self

data/lib/svelte_on_rails/installer/hello_world.rb

@@ -10,35 +10,16 @@ module SvelteOnRails
 
         utils_i.write_templates(templates, ask_for_overwrite: !force, app_root: app_root, silent: silent)
 
-        # route
-
-        route = 'svelte_on_rails_hello_world#index'
-
-        utils_i.add_route("  get \"#{route.sub('#', '/')}\"", app_root: app_root)
-        utils_i.add_route("  get \"svelte_on_rails_hello_world/backend_frontend_rendered\"", app_root: app_root)
-        utils_i.add_route("  get \"svelte_on_rails_hello_world/ssr_auto_rendered\"", app_root: app_root)
-
-        rr = utils_i.which_root_route(app_root)
-        root_url = "/"
-        url = root_url + route.sub('#', '/')
-
-        if rr && rr == route
-          puts "Root route «#{route}» already exists, skipping."
-          root_url
-        elsif rr && utils_i.route_exists?(route.sub('#', '/'))
-          puts "route «#{route}» already exists, skipping."
-          url
-        elsif rr
-          url
-        else
-          utils_i.add_route('  root "svelte_on_rails_hello_world#index"', app_root: app_root)
-          root_url
-        end
+        # routes
+
+        utils_i.add_route("  get \"svelte_on_rails_showcase/backend_frontend_rendered\"", app_root: app_root)
+        utils_i.add_route("  get \"svelte_on_rails_showcase/ssr_auto_rendered\"", app_root: app_root)
+        utils_i.add_route("  get \"svelte_on_rails_showcase\", to: \"svelte_on_rails_showcase#index\"", app_root: app_root)
 
       end
 
 
-      def self.remove_hello_world(templates = ['all_features_test'], app_root: nil, ask: true)
+      def self.remove_hello_world(templates = ['showcase'], app_root: nil, ask: true)
 
         utils = SvelteOnRails::Installer::Utils
 
@@ -58,7 +39,7 @@ module SvelteOnRails
 
         utils.remove_line_from_file(
           utils.app_root_path(app_root).join('config/routes.rb'),
-          "svelte_on_rails_hello_world",
+          "svelte_on_rails_showcase",
           force: !ask,
         )
 

data/lib/svelte_on_rails/installer/utils.rb

@@ -5,12 +5,11 @@ module SvelteOnRails
     module Utils
       def self.install_npm_package
         package_name = "@csedl/svelte-on-rails@latest"
-        puts "Installing #{package_name} via npm..."
 
         if system("npm install #{package_name}")
-          puts "#{package_name} successfully installed."
+          puts "Installed successfully: «#{package_name}»"
         else
-          abort "Failed to install #{package_name}. Please ensure npm is installed and try running 'npm install #{package_name}' manually."
+          abort "Failed to install «#{package_name}» by npm. You must manually."
         end
       end
 
@@ -243,17 +242,6 @@ module SvelteOnRails
         continue == 'y'
       end
 
-      def self.which_root_route(app_root = nil)
-
-        # Check if the root route is active (uncommented) or commented out
-
-        routes = File.read(app_root_path(app_root).join('config', 'routes.rb'))
-        m = routes.match(/^\s*root\s+['"]([^'"]+)['"]/m)
-        if m
-          m.to_s.match(/^\s*root\s*['"]([^'"]*)['"]/)[1]
-        end
-      end
-
       def self.add_route(route, app_root: nil)
 
         file_path = app_root_path(app_root).join('config/routes.rb')

data/lib/svelte_on_rails/lib/development_utils.rb

@@ -1,38 +1,9 @@
 module SvelteOnRails
   class DevelopmentUtils
 
-    def self.local_npm_package_url
-      str = contributor_config('local_npm_package_path', required: false)
-      if !str.present?
-        nil
-      elsif !Dir.exist?(str)
-        raise "Invalid path given on local_npm_package_path: «#{str}»"
-      elsif !File.exist?(Pathname.new(str).join('package.json'))
-        raise "Given local_npm_package_path does not seem to be a valid npm package as it does not contain a package.json"
-      else
-        return Pathname.new(str)
-      end
-    end
-
     def self.gem_folder
       Pathname.new(File.expand_path('../../..', __dir__))
     end
 
-    def self.contributor_config(key, required: true)
-      config_file = File.expand_path('../svelte_on_rails_contributor_configs.yml', gem_folder)
-      if !File.exist?(config_file)
-        if required
-          raise "Missing configuration file, searched at: «#{config_file}»"
-        end
-      else
-        yml = YAML.load_file(config_file)
-        value = yml[key.to_s]
-        if required && !value.present?
-          raise "Missing value «#{key}» in configuration file: «#{config_file}»"
-        end
-        value
-      end
-    end
-
   end
 end

data/lib/svelte_on_rails/lib/utils.rb

@@ -69,6 +69,7 @@ module SvelteOnRails
         errors_matcher = Regexp.new('(Could not resolve|failed to resolve)')
         error_lines = warnings.select { |e| e.match(errors_matcher) }
         have_error = error_lines.present? || status.to_s.match(/exit 1/)
+        copy_render_js
 
         # error handling
 
@@ -118,6 +119,11 @@ module SvelteOnRails
 
       end
 
+      def self.copy_render_js
+        config = SvelteOnRails::Configuration.instance
+        FileUtils.cp(gem_app_dir + 'renderer/render.js', config.ssr_dist_folder.join('render.js'))
+      end
+
       # Defining methods to log errors and warnings using Rails logger
       def self.puts_error(text)
         # Using Rails logger to log error with custom formatting

data/lib/svelte_on_rails/lib/view_helper_support.rb

@@ -9,6 +9,8 @@ module SvelteOnRails
 
       def initialize(file, props, html_options, options, request, caching = false)
 
+        require 'zlib'
+
         @start_time = Time.now
         @conf = SvelteOnRails::Configuration.instance
         utils = SvelteOnRails::Lib::Utils

data/lib/svelte_on_rails/renderer/render-backup.js

@@ -0,0 +1,26 @@
+import {loadComponentModule, readPropsFromStdin} from './utils.js';
+
+(async () => {
+
+    console.log(`[svelte-on-rails:debug] awaiting load component => «${process.argv[2]}»`)
+
+    const MyComponent = await loadComponentModule(process.argv[2]);
+    console.log(`[svelte-on-rails:debug] component read: «${MyComponent}}»`)
+
+    const props = await readPropsFromStdin();
+    console.log(`[svelte-on-rails:debug] props read: «${props}»`)
+
+    const payload = {out: []};
+
+    try {
+        MyComponent(payload, props); // Writes directly to payload.out
+        console.log(`[svelte-on-rails:debug] written to payload (typeof payload.out => «${typeof payload.out}»)`)
+    } catch (error) {
+        console.error('[svelte-on-rails:debug] Error rendering component:', error);
+        process.exit(1);
+    }
+
+    const res = {status: 'SUCCESS', html: payload.out};
+    console.log('[svelte-on-rails:successful-json-response]' + JSON.stringify(res));
+})();
+

data/lib/svelte_on_rails/renderer/render.js

@@ -1,26 +1,74 @@
-import {loadComponentModule, readPropsFromStdin} from './utils.js';
+// render.js (updated for Svelte 5+ SSR rendering with 'svelte/server')
+// this script is, by rails assets:precompile copied to the public assets folder and used from there
+// the reason for doing it this way is that this is the only clean way for using the svelte from frontends package.json
 
-(async () => {
+import {fileURLToPath} from 'node:url';
+import {dirname, resolve} from 'node:path';
+const compiledComponentPath = process.argv[2];
 
-    console.log(`[svelte-on-rails:debug] awaiting load component => «${process.argv[2]}»`)
+import { render } from 'svelte/server';
 
-    const MyComponent = await loadComponentModule(process.argv[2]);
-    console.log(`[svelte-on-rails:debug] component read: «${MyComponent}}»`)
+(async () => {
+    console.log(`[svelte-on-rails:debug] awaiting load component => «${compiledComponentPath}»`);
+    const compiledComponent = await loadComponentModule(compiledComponentPath);
+    console.log(`[svelte-on-rails:debug] component read: «${compiledComponent}»`);
 
     const props = await readPropsFromStdin();
-    console.log(`[svelte-on-rails:debug] props read: «${props}»`)
-
-    const payload = {out: []};
+    console.log(`[svelte-on-rails:debug] props read: «${JSON.stringify(props)}»`);
 
     try {
-        MyComponent(payload, props); // Writes directly to payload.out
-        console.log(`[svelte-on-rails:debug] written to payload (typeof payload.out => «${typeof payload.out}»)`)
+        // Svelte 5+ SSR rendering (runes-compatible; signals omitted on server for perf)
+        // Returns { body: string, head: string } — no 'html' or 'css' props
+        const { body, head } = render(compiledComponent, { props });
+
+        const res = {
+            status: 'SUCCESS',
+            html: body, // Use 'body' as the main HTML content (replaces old 'html')
+            head: head || '', // Optional: Include <head> content (styles, meta, etc.)
+            // Add bodyAttributes or other result props if needed in future
+        };
+
+        console.log('[svelte-on-rails:successful-json-response]' + JSON.stringify(res));
     } catch (error) {
         console.error('[svelte-on-rails:debug] Error rendering component:', error);
         process.exit(1);
     }
-
-    const res = {status: 'SUCCESS', html: payload.out};
-    console.log('[svelte-on-rails:successful-json-response]' + JSON.stringify(res));
 })();
 
+async function loadComponentModule(compiledFile) {
+    // Get the directory of the current script
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname(__filename);
+
+    try {
+        // Convert relative path to absolute path
+        const absolutePath = resolve(__dirname, compiledFile);
+
+        // Convert absolute path to a file URL
+        const modulePath = `file://${absolutePath}`;
+
+        // Import the module
+        const module = await import(modulePath);
+        return module.default;
+    } catch (error) {
+        console.error(`=> compiledFile: «${compiledFile}»`);
+        console.error(`[loadComponentModule] Error loading component from ${compiledFile}:`, error);
+        process.exit(1);
+    }
+}
+
+function readPropsFromStdin() {
+    return new Promise((resolve, reject) => {
+        let input = '';
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', (chunk) => (input += chunk));
+        process.stdin.on('end', () => {
+            try {
+                resolve(JSON.parse(input));
+            } catch (error) {
+                reject(new Error(`Error parsing JSON from STDIN: ${error.message}\nInput: «${input}»`));
+            }
+        });
+        process.stdin.on('error', (error) => reject(new Error(`Error reading STDIN: ${error.message}`)));
+    });
+}

data/lib/svelte_on_rails/renderer/renderer.rb

@@ -26,12 +26,15 @@ module SvelteOnRails
 
       cmd = [
         cnf.node_bin_path,
-        File.join(utils.gem_app_dir, 'renderer', 'render.js'),
-        @component_files[:compiled_file] + '.js',
-        cnf.rails_root
+        cnf.ssr_dist_folder.join('render.js'),
+        @component_files[:compiled_file] + '.js'
       ].join(' ')
 
-      stdout, stderr, status = Open3.capture3(cmd, stdin_data: props.to_json, chdir: cnf.rails_root)
+      stdout, stderr, status = Open3.capture3(
+        cmd,
+        stdin_data: props.to_json,
+      chdir: cnf.rails_root,
+      )
 
       ary = stdout.split('[svelte-on-rails:successful-json-response]')