salvia 0.2.0 → 0.2.2

data/lib/salvia/core/import_map.rb

@@ -5,32 +5,132 @@ require "json"
 module Salvia
   module Core
     class ImportMap
-    def self.load
-      new.load
-    end
+      def self.generate(additional_map = {})
+        new.generate(additional_map)
+      end
+
+      def generate(additional_map = {})
+        map = { "imports" => default_imports }
+        
+        # Merge imports from deno.json
+        deno_imports = load_deno_imports
+        map["imports"].merge!(deno_imports) if deno_imports
 
-    def load
-      path = find_deno_json
-      return {} unless path
+        # Merge islands mapping
+        map["imports"].merge!(islands_mapping)
 
-      begin
-        content = File.read(path)
-        json = JSON.parse(content)
-        json["imports"] || {}
-      rescue JSON::ParserError
-        {}
+        # Merge additional map
+        if additional_map["imports"]
+          map["imports"].merge!(additional_map["imports"])
+        end
+        
+        # Merge other keys
+        additional_map.each do |k, v|
+          next if k == "imports"
+          map[k] = v
+        end
+
+        map
       end
-    end
 
-    def keys
-      load.keys
-    end
+      def load
+        path = find_deno_json
+        return {} unless path
 
-    private
+        begin
+          content = File.read(path)
+          json = JSON.parse(content)
+          json["imports"] || {}
+        rescue JSON::ParserError
+          {}
+        end
+      end
 
-    def find_deno_json
-      Salvia.config.deno_config_path
-    end
+      def keys
+        load.keys
+      end
+
+      private
+
+      def default_imports
+        {
+          "preact" => "https://esm.sh/preact@10.19.6",
+          "preact/hooks" => "https://esm.sh/preact@10.19.6/hooks",
+          "preact/jsx-runtime" => "https://esm.sh/preact@10.19.6/jsx-runtime",
+          "@hotwired/turbo" => "https://esm.sh/@hotwired/turbo@8.0.0"
+        }
+      end
+
+      def load_deno_imports
+        imports = load
+        return nil if imports.empty?
+
+        # Convert npm: scheme to https://esm.sh/
+        imports.transform_values do |v|
+          if v.is_a?(String) && v.start_with?("npm:")
+            package = v.sub("npm:", "")
+            "https://esm.sh/#{package}"
+          else
+            v
+          end
+        end
+      end
+
+      def islands_mapping
+        mapping = {}
+        islands_path = Salvia.development? ? "/salvia/assets/islands/" : "/assets/islands/"
+        
+        # Base mapping for directory
+        mapping["@/islands/"] = islands_path
+
+        if Salvia.development?
+          # Development: Scan islands directory and map each component
+          # This ensures we can import "Counter" and get "Counter.tsx" (or whatever DevServer serves)
+          # Note: DevServer should handle extension resolution or we map to specific files here.
+          # Assuming DevServer handles extensionless requests or we map to .js if compiled on the fly.
+          # For now, we map to the file path relative to islands_path.
+          # If we use Sidecar/DevServer, it likely serves compiled JS.
+          
+          # Scan app/islands
+          islands_dir = Salvia.config.islands_dir
+          if File.directory?(islands_dir)
+            Dir.glob("#{islands_dir}/**/*.{tsx,jsx,js}").each do |file|
+              next if File.basename(file).start_with?("_")
+              
+              name = File.basename(file, ".*")
+              # Map "Counter" -> "/salvia/assets/islands/Counter.tsx" (or let DevServer handle it)
+              # If we map to extensionless, browser requests extensionless.
+              # Let's assume DevServer handles it.
+              # But to be safe and consistent with prod, we might want to map to a specific URL.
+              
+              # For simplicity in dev, we can just rely on @/islands/ prefix if imports use extensions.
+              # But if imports are "Counter", we need a map.
+              mapping["@/islands/#{name}"] = File.join(islands_path, File.basename(file))
+            end
+          end
+        else
+          # Production: Use manifest
+          manifest_path = File.join(Salvia.root, "salvia/server/manifest.json")
+          if File.exist?(manifest_path)
+            begin
+              manifest = JSON.parse(File.read(manifest_path))
+              manifest.each do |name, info|
+                if info["file"]
+                  mapping["@/islands/#{name}"] = File.join(islands_path, info["file"])
+                end
+              end
+            rescue JSON::ParserError
+              # Ignore error
+            end
+          end
+        end
+        
+        mapping
+      end
+
+      def find_deno_json
+        Salvia.config.deno_config_path
+      end
     end
   end
 end

data/lib/salvia/helpers/island.rb

@@ -40,57 +40,11 @@ module Salvia
       
       # Import Map タグを生成する
       def salvia_import_map(additional_map = {})
-        default_map = {
-          "imports" => {
-            "preact" => "https://esm.sh/preact@10.19.6",
-            "preact/hooks" => "https://esm.sh/preact@10.19.6/hooks",
-            "preact/jsx-runtime" => "https://esm.sh/preact@10.19.6/jsx-runtime",
-            "@hotwired/turbo" => "https://esm.sh/@hotwired/turbo@8.0.0"
-          }
-        }
-
-        # Islands path mapping
-        islands_path = if defined?(Salvia.env) && Salvia.env == "development"
-                         "/salvia/assets/islands/"
-                       else
-                         "/assets/islands/"
-                       end
-        default_map["imports"]["@/islands/"] = islands_path
-
-        # deno.json から imports を読み込む
-        begin
-          deno_json_path = File.join(Salvia.root, "salvia/deno.json")
-          if File.exist?(deno_json_path)
-            deno_config = JSON.parse(File.read(deno_json_path))
-            if deno_config["imports"]
-              # npm: スキームを https://esm.sh/ に変換してブラウザで使えるようにする
-              imports = deno_config["imports"].transform_values do |v|
-                if v.is_a?(String) && v.start_with?("npm:")
-                  package = v.sub("npm:", "")
-                  "https://esm.sh/#{package}"
-                else
-                  v
-                end
-              end
-              default_map["imports"].merge!(imports)
-            end
-          end
-        rescue => e
-          # 読み込みエラー時は無視
-        end
-
-        if additional_map.key?("imports")
-          default_map["imports"].merge!(additional_map["imports"])
-        end
-        
-        additional_map.each do |k, v|
-          next if k == "imports"
-          default_map[k] = v
-        end
+        map = Salvia::Core::ImportMap.generate(additional_map)
         
         html = <<~HTML
           <script type="importmap">
-            #{default_map.to_json}
+            #{map.to_json}
           </script>
         HTML
         
@@ -120,7 +74,9 @@ module Salvia
       # @example ハイドレーションを無効化 (静的 HTML のみ)
       #   <%= island "StaticCard", title: "Hello", hydrate: false %>
       #
+      # @deprecated Use Salvia::SSR.render in controller instead.
       def island(name, props = {}, options = {})
+        warn "[DEPRECATION] `island` helper is deprecated. Please use `Salvia::SSR.render` in your controller (API Mode) instead."
         tag_name = options.delete(:tag) || :div
         
         # デフォルトの hydrate 値を決定
@@ -190,18 +146,11 @@ module Salvia
       #
       # @param name [String] ページコンポーネント名 (例: "pages/Home")
       # @param props [Hash] プロパティ
+      # @param options [Hash] オプション
+      # @option options [Boolean] :doctype <!DOCTYPE html> を付与するか (デフォルト: true)
       # @return [String] 完全な HTML 文字列
-      def ssr(name, props = {})
-        # SSR で HTML を生成
-        html = Salvia::SSR.render(name, props)
-        
-        # <head> がある場合、Import Map を自動注入
-        if html.include?("</head>")
-          import_map_html = salvia_import_map
-          html = html.sub("</head>", "#{import_map_html}</head>")
-        end
-        
-        result = "<!DOCTYPE html>\n" + html
+      def ssr(name, props = {}, options = {})
+        result = Salvia::SSR.render_page(name, props, options)
         result.respond_to?(:html_safe) ? result.html_safe : result
       end
       

data/lib/salvia/server/dev_server.rb

@@ -7,14 +7,23 @@ module Salvia
 
     def call(env)
       # Only active in development
-      unless ENV["RACK_ENV"] == "development" || ENV["RAILS_ENV"] == "development"
-        return @app.call(env)
-      end
+      # Prefer Rails.env if available, otherwise check ENV
+      is_dev = if defined?(Rails) && Rails.respond_to?(:env)
+                 Rails.env.development?
+               else
+                 ENV["RACK_ENV"] == "development" || ENV["RAILS_ENV"] == "development"
+               end
+
+      return @app.call(env) unless is_dev
 
       request = Rack::Request.new(env)
       
       if request.path.start_with?("/salvia/assets/")
         handle_asset_request(request)
+      elsif request.path == "/assets/javascripts/islands.js"
+        # Handle islands.js specifically for development convenience
+        # This matches the path used in Home.tsx template and ensures it works without build
+        serve_islands_js
       else
         @app.call(env)
       end
@@ -31,8 +40,9 @@ module Salvia
         return serve_islands_js
       end
       
-      # Remove .js extension to find source
-      base_name = path_info.sub(/\.js$/, "")
+      # Remove extension to find source (supports .js, .tsx, .ts, .jsx)
+      # Also handle requests without extension (from import map resolution)
+      base_name = path_info.sub(/\.(js|tsx|ts|jsx)$/, "")
       
       source_path = resolve_source_path(base_name)
       
@@ -44,8 +54,6 @@ module Salvia
         # Bundle for browser (ESM)
         # We externalize dependencies that should be handled by Import Map
         externals = Salvia::Core::ImportMap.new.keys
-        # Always externalize framework aliases just in case
-        externals += ["framework", "framework/hooks", "framework/jsx-runtime"]
         
         js_code = Salvia::Compiler.bundle(
           source_path, 
@@ -64,13 +72,19 @@ module Salvia
     end
 
     def serve_islands_js
-      # Check user's islands.js
+      # 1. Check public assets (Build output or user override)
+      public_path = File.join(Salvia.root, "public/assets/javascripts/islands.js")
+      if File.exist?(public_path)
+        return [200, { "content-type" => "application/javascript" }, [File.read(public_path)]]
+      end
+
+      # 2. Check user's source (salvia/assets/javascripts/islands.js) - Legacy/Custom path
       user_path = File.join(Salvia.root, "salvia/assets/javascripts/islands.js")
       if File.exist?(user_path)
         return [200, { "content-type" => "application/javascript" }, [File.read(user_path)]]
       end
       
-      # Fallback to internal islands.js
+      # 3. Fallback to internal islands.js
       internal_path = File.expand_path("../../../assets/javascripts/islands.js", __dir__)
       if File.exist?(internal_path)
         return [200, { "content-type" => "application/javascript" }, [File.read(internal_path)]]

data/lib/salvia/server/sidecar.rb

@@ -6,7 +6,7 @@ require 'timeout'
 module Salvia
   module Server
     class Sidecar
-    SCRIPT_PATH = File.join(__dir__, "sidecar.ts")
+    SCRIPT_PATH = File.expand_path("../../../assets/scripts/sidecar.ts", __dir__)
 
     def self.instance
       @instance ||= new
@@ -15,45 +15,70 @@ module Salvia
     def initialize
       @pid = nil
       @port = nil
+      @mutex = Mutex.new
       at_exit { stop }
     end
 
     def start
-      return if running?
+      @mutex.synchronize do
+        return if running?
 
-      cmd = ["deno", "run", "--allow-all", SCRIPT_PATH]
-      
-      puts "🚀 Starting Salvia Sidecar..."
-      # Spawn process and capture stdout to find the port
-      # We use IO.popen to read the output stream
-      @io = IO.popen(cmd)
-      @pid = @io.pid
-      
-      # Wait for "Listening on http://localhost:PORT/"
-      wait_for_port
-      
-      # Detach so it runs in background, but we keep the IO open to read logs if needed
-      # Actually, for IO.popen, we shouldn't detach if we want to read from it.
-      # But we need to read in a non-blocking way or in a separate thread after finding the port.
-      
-      Thread.new do
-        begin
-          while line = @io.gets
-            # Forward Deno logs to stdout/logger
-            puts "[Deno] #{line}"
+        cmd = ["deno", "run", "--allow-net", "--allow-read", "--allow-env", "--allow-run", SCRIPT_PATH]
+        
+        puts "🚀 Starting Salvia Sidecar..."
+        # Spawn process and capture stdout to find the port
+        # We use IO.popen to read the output stream
+        @io = IO.popen(cmd, err: [:child, :out])
+        @pid = @io.pid
+        
+        # Wait for JSON handshake
+        wait_for_handshake
+        
+        # Detach so it runs in background, but we keep the IO open to read logs if needed
+        # Actually, for IO.popen, we shouldn't detach if we want to read from it.
+        # But we need to read in a non-blocking way or in a separate thread after finding the port.
+        
+        Thread.new do
+          begin
+            while line = @io.gets
+              # Forward Deno logs to stdout/logger
+              puts "[Deno] #{line}"
+            end
+          rescue IOError
+            # Stream closed
           end
-        rescue IOError
-          # Stream closed
         end
       end
     end
 
     def stop
       return unless @pid
-      Process.kill("TERM", @pid)
-      @pid = nil
-      @port = nil
-      @io.close if @io && !@io.closed?
+      
+      begin
+        Process.kill("TERM", @pid)
+        
+        # Wait up to 5 seconds for graceful shutdown
+        50.times do
+          pid = Process.waitpid(@pid, Process::WNOHANG)
+          if pid
+            @pid = nil
+            break
+          end
+          sleep 0.1
+        end
+        
+        # Force kill if still running
+        if @pid
+          Process.kill("KILL", @pid)
+          Process.waitpid(@pid, Process::WNOHANG) rescue nil
+        end
+      rescue Errno::ESRCH, Errno::ECHILD
+        # Process already dead
+      ensure
+        @pid = nil
+        @port = nil
+        @io.close if @io && !@io.closed?
+      end
     end
 
     def running?
@@ -97,16 +122,28 @@ module Salvia
 
     private
 
-    def wait_for_port
-      Timeout.timeout(10) do
+    def wait_for_handshake
+      Timeout.timeout(30) do
         while line = @io.gets
-          puts "[Deno Init] #{line}"
-          if match = line.match(/Listening on http:\/\/localhost:(\d+)\//)
-            @port = match[1].to_i
-            puts "✅ Salvia Sidecar connected on port #{@port}"
-            return
+          # Try to parse JSON handshake
+          if line.strip.start_with?("{") && line.include?("port")
+            begin
+              data = JSON.parse(line)
+              if data["port"]
+                @port = data["port"]
+                puts "✅ Salvia Sidecar connected on port #{@port}"
+                return
+              end
+            rescue JSON::ParserError
+              # Not JSON, just log
+              puts "[Deno Init] #{line}"
+            end
+          else
+            puts "[Deno Init] #{line}"
           end
         end
+        # If we exit the loop, it means EOF (process died)
+        raise "Deno Sidecar crashed unexpectedly. Check logs."
       end
     rescue Timeout::Error
       stop

data/lib/salvia/ssr/dom_mock.rb

@@ -12,12 +12,20 @@ module Salvia
             globalThis.addEventListener = function() {};
             globalThis.removeEventListener = function() {};
             globalThis.document = {
-              createElement: function() { return {}; },
+              createElement: function(tag) {
+                return {
+                  tagName: tag ? tag.toUpperCase() : 'DIV',
+                  setAttribute: function() {},
+                  appendChild: function() {},
+                  style: {}
+                };
+              },
               createTextNode: function() { return {}; },
               addEventListener: function() { },
               removeEventListener: function() { },
-              head: {},
-              body: {},
+              head: { appendChild: function() {} },
+              body: { appendChild: function() {} },
+              getElementById: function() { return null; },
               documentElement: {
                 addEventListener: function() { },
                 removeEventListener: function() { }