salvia 0.2.0

data/lib/salvia/server/sidecar.ts

@@ -0,0 +1,167 @@
+import * as esbuild from "https://deno.land/x/esbuild@v0.24.2/mod.js";
+import { denoPlugins } from "jsr:@luca/esbuild-deno-loader@0.11";
+
+// Use port 0 to let OS assign a free port
+const PORT = 0;
+
+console.log(`[Deno Init] 🚀 Salvia Sidecar starting...`);
+
+const handler = async (request: Request): Promise<Response> => {
+  if (request.method !== "POST") {
+    return new Response("Method Not Allowed", { status: 405 });
+  }
+
+  try {
+    const body = await request.json();
+    const { command, params } = body;
+
+    if (command === "bundle") {
+      const { entryPoint, externals, format, globalName, configPath } = params;
+      
+      // If format is IIFE, we need to handle externals by mapping them to globals
+      // But esbuild doesn't support this out of the box for IIFE with externals.
+      // We can use a plugin to rewrite imports to globals if they are in externals list.
+      
+        // 4. Global Externals (for IIFE format)
+        const globalExternalsPlugin = {
+            name: "global-externals",
+            setup(build: any) {
+              // Preact
+              build.onResolve({ filter: /^preact$/ }, (args: any) => {
+                return { path: args.path, namespace: "global-external" };
+              });
+              // Hooks
+              build.onResolve({ filter: /^preact\/hooks$/ }, (args: any) => {
+                return { path: args.path, namespace: "global-external" };
+              });
+              // Signals
+              build.onResolve({ filter: /^@preact\/signals$/ }, (args: any) => {
+                return { path: args.path, namespace: "global-external" };
+              });
+              // JSX Runtime
+              build.onResolve({ filter: /^preact\/jsx-runtime$/ }, (args: any) => {
+                return { path: args.path, namespace: "global-external" };
+              });
+
+              build.onLoad({ filter: /.*/, namespace: "global-external" }, (args: any) => {
+                if (args.path === "preact") return { contents: "module.exports = globalThis.Preact;", loader: "js" };
+                if (args.path === "preact/hooks") return { contents: "module.exports = globalThis.PreactHooks;", loader: "js" };
+                if (args.path === "@preact/signals") return { contents: "module.exports = globalThis.PreactSignals;", loader: "js" };
+                if (args.path === "preact/jsx-runtime") return { contents: "module.exports = globalThis.PreactJsxRuntime;", loader: "js" };
+                return null;
+              });
+            },
+        };
+
+      const externalizePlugin = {
+        name: 'externalize-deps',
+        setup(build: any) {
+          build.onResolve({ filter: /.*/ }, (args: any) => {
+            if (externals && externals.includes(args.path)) {
+              return { path: args.path, external: true };
+            }
+          });
+        },
+      };
+
+      const isIIFE = format === "iife";
+      
+      const plugins = [
+        ...denoPlugins({ configPath: configPath || `${Deno.cwd()}/salvia/deno.json` })
+      ];
+      
+      if (isIIFE && !entryPoint.endsWith("vendor_setup.ts")) {
+        // IIFEの場合は、globalExternalsPlugin を使う
+        // ただし、denoPlugins よりも前に配置して、framework などの解決を横取りする
+        plugins.unshift(globalExternalsPlugin);
+      } else {
+        plugins.unshift(externalizePlugin);
+      }
+
+      // JIT Bundle for a specific entry point
+      const result = await esbuild.build({
+        entryPoints: [entryPoint],
+        bundle: true,
+        format: format || "esm",
+        globalName: globalName || undefined, // Exports will be in SalviaComponent.default
+        platform: "neutral",
+        plugins: plugins,
+        external: [], // We handle externals manually with plugins
+        write: false, // Return in memory
+    // 3. JSX Runtime (Automatic)
+    // deno.json の "preact/jsx-runtime" エイリアスを使用
+    jsx: "automatic",
+    jsxImportSource: "preact",
+        minify: false, // Keep it readable for debugging
+      });
+
+      const code = result.outputFiles[0].text;
+      // Deno.writeTextFileSync("debug_bundle.js", code);
+
+      return new Response(JSON.stringify({ code }), {
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+
+    if (command === "check") {
+      const { entryPoint, configPath } = params;
+      const cmd = new Deno.Command("deno", {
+        args: ["check", "--config", configPath || "deno.json", entryPoint],
+        stdout: "piped",
+        stderr: "piped",
+        cwd: Deno.cwd(),
+      });
+      
+      const output = await cmd.output();
+      const success = output.code === 0;
+      const message = new TextDecoder().decode(output.stderr);
+      
+      return new Response(JSON.stringify({ success, message }), {
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    
+    if (command === "fmt") {
+      const { entryPoint, configPath } = params;
+      const cmd = new Deno.Command("deno", {
+        args: ["fmt", "--config", configPath || "deno.json", entryPoint],
+        stdout: "piped",
+        stderr: "piped",
+        cwd: Deno.cwd(),
+      });
+      
+      const output = await cmd.output();
+      const success = output.code === 0;
+      const message = new TextDecoder().decode(output.stderr);
+      
+      return new Response(JSON.stringify({ success, message }), {
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    
+    if (command === "ping") {
+        return new Response(JSON.stringify({ status: "pong" }));
+    }
+
+    return new Response("Unknown command", { status: 400 });
+
+  } catch (e) {
+    const err = e as Error;
+    console.error("Sidecar Error:", err);
+    return new Response(JSON.stringify({ error: err.message }), { status: 500 });
+  }
+};
+
+const server = Deno.serve({ port: PORT }, handler);
+// Output the assigned port so Ruby can read it
+console.log(`[Deno Init] Listening on http://localhost:${server.addr.port}/`);
+
+// Handle cleanup on exit
+const cleanup = () => {
+  console.log("🛑 Stopping Sidecar...");
+  esbuild.stop();
+  Deno.exit();
+};
+
+Deno.addSignalListener("SIGINT", cleanup);
+Deno.addSignalListener("SIGTERM", cleanup);

data/lib/salvia/ssr/dom_mock.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Salvia
+  module SSR
+    module DomMock
+      def self.generate_shim
+        <<~JS
+          (function() {
+            // Mock DOM globals for SSR
+            globalThis.window = globalThis;
+            globalThis.self = globalThis;
+            globalThis.addEventListener = function() {};
+            globalThis.removeEventListener = function() {};
+            globalThis.document = {
+              createElement: function() { return {}; },
+              createTextNode: function() { return {}; },
+              addEventListener: function() { },
+              removeEventListener: function() { },
+              head: {},
+              body: {},
+              documentElement: {
+                addEventListener: function() { },
+                removeEventListener: function() { }
+              }
+            };
+            globalThis.HTMLFormElement = class {};
+            globalThis.HTMLElement = class {};
+            globalThis.Element = class {};
+            globalThis.Node = class {};
+            globalThis.Event = class {};
+            globalThis.CustomEvent = class {};
+            globalThis.URL = class { 
+              constructor(url) { this.href = url; } 
+              static createObjectURL() { return ""; }
+              static revokeObjectURL() { }
+            };
+            globalThis.requestAnimationFrame = function(cb) { return setTimeout(cb, 0); };
+            globalThis.cancelAnimationFrame = function(id) { clearTimeout(id); };
+            globalThis.navigator = { userAgent: 'SalviaSSR' };
+            globalThis.location = { href: 'http://localhost' };
+          })();
+        JS
+      end
+    end
+  end
+end

data/lib/salvia/ssr/quickjs.rb

@@ -0,0 +1,282 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Salvia
+  module SSR
+    class QuickJS < BaseAdapter
+      attr_reader :js_logs
+      attr_accessor :last_build_error
+
+      def setup!
+        require_quickjs!
+        
+        @js_logs = []
+        @last_build_error = nil
+        @development = options.fetch(:development, true)
+        
+        @vm = ::Quickjs::VM.new
+        
+        load_console_shim!
+        
+        if @development
+          load_vendor_bundle!
+        else
+          load_ssr_bundle!
+        end
+        
+        mark_initialized!
+      end
+      
+      def shutdown!
+        @vm = nil
+        @js_logs = []
+        @initialized = false
+        Salvia::Compiler.shutdown if @development
+      end
+
+      def render(component_name, props = {})
+        log_info("[Salvia] Rendering #{component_name}") if @development
+        raise Error, "Engine not initialized" unless initialized?
+        
+        if @development
+          render_jit(component_name, props)
+        else
+          render_production(component_name, props)
+        end
+      end
+
+      private
+
+      def vm
+        @vm
+      end
+
+      def render_jit(component_name, props)
+        begin
+          path = resolve_path(component_name)
+          unless path
+            raise Error, "Component not found: #{component_name}"
+          end
+          
+          # Bundle component
+          js_code = Salvia::Compiler.bundle(
+            path, 
+            externals: ["preact", "preact/hooks", "preact-render-to-string"],
+            format: "iife",
+            global_name: "SalviaComponent"
+          )
+          
+          # Async Type Check
+          Thread.new do
+            begin
+              result = Salvia::Compiler.check(path)
+              unless result["success"]
+                log_warn("Type Check Failed for #{component_name}:\n#{result["message"]}")
+              end
+            rescue => e
+              log_debug("Type Check Error: #{e.message}")
+            end
+          end
+
+          eval_js(js_code)
+          
+          # Render
+          render_script = <<~JS
+            (function() {
+              try {
+                const Component = SalviaComponent.default;
+                if (!Component) throw new Error("Component default export not found in " + "#{escape_js(component_name)}");
+                const vnode = h(Component, #{props.to_json});
+                const html = renderToString(vnode);
+                return JSON.stringify(html);
+              } catch (e) {
+                return JSON.stringify({ __ssr_error__: true, message: e.message, stack: e.stack || '' });
+              }
+            })()
+          JS
+          
+          result = eval_js(render_script)
+          
+          begin
+            parsed = JSON.parse(result)
+            if parsed.is_a?(Hash) && parsed["__ssr_error__"]
+              @last_build_error = parsed['message']
+              return ssr_error_overlay(component_name, parsed)
+            end
+            return parsed
+          rescue JSON::ParserError
+            if result.nil?
+              log_error("Render result is nil")
+              return nil
+            end
+            return result
+          end
+        rescue => e
+          log_error("Render JIT Error: #{e.message}")
+          @last_build_error = e.message
+          return build_error_html(e.message)
+        end
+      end
+
+      def render_production(component_name, props)
+        js_code = <<~JS
+          (function() {
+            try {
+              if (typeof globalThis.SalviaSSR === 'undefined') {
+                throw new Error('SalviaSSR runtime not loaded.');
+              }
+              const html = globalThis.SalviaSSR.render('#{escape_js(component_name)}', #{props.to_json});
+              return JSON.stringify(html);
+            } catch (e) {
+              return JSON.stringify({ __ssr_error__: true, message: e.message, stack: e.stack || '' });
+            }
+          })()
+        JS
+
+        result = eval_js(js_code)
+        
+        begin
+          parsed = JSON.parse(result)
+          if parsed.is_a?(Hash) && parsed["__ssr_error__"]
+            return ssr_error_overlay(component_name, parsed)
+          end
+          return parsed
+        rescue JSON::ParserError
+          return result
+        end
+      end
+
+      def eval_js(code)
+        result = @vm.eval_code(code)
+        process_console_output
+        result
+      rescue => e
+        process_console_output
+        raise e
+      end
+      
+      def load_console_shim!
+        shim = generate_console_shim
+        @vm.eval_code(shim)
+        @vm.eval_code(Salvia::SSR::DomMock.generate_shim)
+      rescue => e
+        log_error("Failed to load console shim: #{e.message}")
+      end
+      
+      def load_vendor_bundle!
+        # Use internal vendor_setup.ts for Zero Config
+        vendor_path = File.expand_path("../../../assets/scripts/vendor_setup.ts", __dir__)
+        
+        if File.exist?(vendor_path)
+          code = Salvia::Compiler.bundle(vendor_path, format: "iife")
+          eval_js(code)
+          log_info("Loaded Vendor bundle (Internal)")
+        else
+          log_error("Internal vendor_setup.ts not found at #{vendor_path}")
+        end
+      rescue => e
+        log_error("Failed to load vendor bundle: #{e.message}")
+      end
+      
+      def load_ssr_bundle!
+        bundle_path = options[:bundle_path] || default_bundle_path
+        
+        unless File.exist?(bundle_path)
+          raise Error, "SSR bundle not found: #{bundle_path}"
+        end
+        
+        bundle_content = File.read(bundle_path)
+        @vm.eval_code(bundle_content)
+        log_info("Loaded SSR bundle: #{bundle_path}")
+      end
+      
+      def resolve_path(name)
+        Salvia::Core::PathResolver.resolve(name)
+      end
+      
+      def process_console_output
+        logs_json = @vm.eval_code("globalThis.__salvia_flush_logs__()")
+        return if logs_json.nil? || logs_json.empty?
+        
+        begin
+          logs = JSON.parse(logs_json)
+          logs.each do |log|
+            @js_logs << log
+            case log["level"]
+            when "error"
+              log_error("JS: #{log['message']}")
+            when "warn"
+              log_warn("JS: #{log['message']}")
+            else
+              log_debug("JS: #{log['message']}")
+            end
+          end
+        rescue JSON::ParserError
+        end
+      end
+
+      def generate_console_shim
+        <<~JS
+          (function() {
+            var __salvia_logs__ = [];
+            globalThis.console = {
+              log: function() { __salvia_logs__.push({ level: 'log', message: Array.from(arguments).join(' ') }); },
+              error: function() { __salvia_logs__.push({ level: 'error', message: Array.from(arguments).join(' ') }); },
+              warn: function() { __salvia_logs__.push({ level: 'warn', message: Array.from(arguments).join(' ') }); },
+              info: function() { __salvia_logs__.push({ level: 'info', message: Array.from(arguments).join(' ') }); },
+              debug: function() { __salvia_logs__.push({ level: 'debug', message: Array.from(arguments).join(' ') }); }
+            };
+            globalThis.__salvia_flush_logs__ = function() {
+              var logs = __salvia_logs__;
+              __salvia_logs__ = [];
+              return JSON.stringify(logs);
+            };
+          })();
+        JS
+      end
+
+      def ssr_error_overlay(component_name, error_data)
+        <<~HTML
+          <div style="background:#fee;border:2px solid #c00;padding:20px;margin:10px 0;">
+            <h3>SSR Error in #{escape_html(component_name)}</h3>
+            <pre>#{escape_html(error_data['message'])}</pre>
+            <details><summary>Stack Trace</summary><pre>#{escape_html(error_data['stack'])}</pre></details>
+          </div>
+        HTML
+      end
+      
+      def build_error_html(error_message)
+        <<~HTML
+          <div style="background:#1a1a2e;color:#ff6b6b;padding:20px;position:fixed;inset:0;z-index:9999;">
+            <h2>SSR Build Failed</h2>
+            <pre>#{escape_html(error_message)}</pre>
+          </div>
+        HTML
+      end
+
+      def default_bundle_path
+        File.join(Dir.pwd, "salvia", "server", "ssr_bundle.js")
+      end
+
+      def require_quickjs!
+        require "quickjs"
+      rescue LoadError
+        raise Error, "quickjs gem is not installed."
+      end
+
+      def escape_js(str)
+        str.to_s.gsub(/['\\]/) { |c| "\\#{c}" }
+      end
+      
+      def escape_html(str)
+        str.to_s.gsub("&", "&amp;").gsub("<", "&lt;").gsub(">", "&gt;").gsub('"', "&quot;")
+      end
+      
+      def log_info(msg); defined?(Salvia.logger) ? Salvia.logger.info(msg) : puts("[SSR] #{msg}"); end
+      def log_warn(msg); defined?(Salvia.logger) ? Salvia.logger.warn(msg) : puts("[SSR WARNING] #{msg}"); end
+      def log_error(msg); defined?(Salvia.logger) ? Salvia.logger.error(msg) : puts("[SSR ERROR] #{msg}"); end
+      def log_debug(msg); defined?(Salvia.logger) ? Salvia.logger.debug(msg) : puts("[SSR DEBUG] #{msg}") if ENV["DEBUG"]; end
+    end
+  end
+end

data/lib/salvia/ssr.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Salvia
+  module SSR
+    class Error < Salvia::Error; end
+    class EngineNotFoundError < Error; end
+    class RenderError < Error; end
+
+    # SSR アダプターの基底クラス
+    class BaseAdapter
+      attr_reader :options
+
+      def initialize(options = {})
+        @options = options
+        @initialized = false
+      end
+
+      # エンジンを初期化
+      def setup!
+        raise NotImplementedError, "#{self.class}#setup! must be implemented"
+      end
+
+      # コンポーネントをレンダリング
+      # @param component_name [String] コンポーネント名
+      # @param props [Hash] プロパティ
+      # @return [String] レンダリングされた HTML
+      def render(component_name, props = {})
+        raise NotImplementedError, "#{self.class}#render must be implemented"
+      end
+
+      # コンポーネントを登録
+      # @param name [String] コンポーネント名
+      # @param code [String] コンポーネントの JS コード
+      def register_component(name, code)
+        raise NotImplementedError, "#{self.class}#register_component must be implemented"
+      end
+
+      # エンジンをシャットダウン
+      def shutdown!
+        # オーバーライド可能
+      end
+
+      def initialized?
+        @initialized
+      end
+
+      # エンジン名
+      def engine_name
+        raise NotImplementedError
+      end
+
+      protected
+
+      def mark_initialized!
+        @initialized = true
+      end
+    end
+
+    class << self
+      attr_accessor :current_adapter
+      attr_accessor :last_build_error
+
+      # SSR エンジンを設定
+      # @param options [Hash] エンジンオプション
+      # @option options [String] :bundle_path SSR バンドルのパス
+      # @option options [Boolean] :development 開発モード
+      def configure(options = {})
+        require_relative "ssr/quickjs"
+        @current_adapter = QuickJS.new(options)
+        @current_adapter.setup!
+        @current_adapter
+      end
+
+      # コンポーネントをレンダリング
+      # @param component_name [String] コンポーネント名
+      # @param props [Hash] プロパティ
+      # @return [String] レンダリングされた HTML
+      def render(component_name, props = {})
+        raise Error, "SSR not configured. Call Salvia::SSR.configure first." unless current_adapter
+        current_adapter.render(component_name, props)
+      end
+
+      # コンポーネントを登録
+      def register_component(name, code)
+        raise Error, "SSR not configured. Call Salvia::SSR.configure first." unless current_adapter
+        current_adapter.register_component(name, code)
+      end
+      
+      # バンドルをリロード (開発モード用)
+      def reload!
+        return unless current_adapter
+        current_adapter.reload_bundle! if current_adapter.respond_to?(:reload_bundle!)
+      end
+      
+      # ビルドエラーを設定
+      def set_build_error(error)
+        @last_build_error = error
+        current_adapter.last_build_error = error if current_adapter&.respond_to?(:last_build_error=)
+      end
+      
+      # ビルドエラーをクリア
+      def clear_build_error
+        @last_build_error = nil
+        current_adapter.last_build_error = nil if current_adapter&.respond_to?(:last_build_error=)
+      end
+
+      # シャットダウン
+      def shutdown!
+        current_adapter&.shutdown!
+        @current_adapter = nil
+      end
+
+      # 設定済みか確認
+      def configured?
+        !current_adapter.nil? && current_adapter.initialized?
+      end
+    end
+  end
+end

data/lib/salvia/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Salvia
+  VERSION = "0.2.0"
+end

data/lib/salvia.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative "salvia/version"
+
+require "rack"
+require "zeitwerk"
+require "logger"
+
+loader = Zeitwerk::Loader.for_gem
+loader.ignore("#{__dir__}/salvia/version.rb")
+loader.inflector.inflect(
+  "salvia" => "Salvia",
+  "cli" => "CLI",
+  "ssr" => "SSR"
+)
+loader.setup
+
+module Salvia
+  # Alias Core classes for backward compatibility
+  Error = Core::Error
+  Configuration = Core::Configuration
+
+  class << self
+    attr_accessor :root, :env, :logger
+
+    def logger
+      @logger ||= Logger.new(STDOUT)
+    end
+
+    def config
+      @config ||= Core::Configuration.new
+    end
+
+    def configure
+      yield config if block_given?
+      
+      # Initialize SSR engine
+      if defined?(Salvia::SSR)
+        Salvia::SSR.configure(
+          bundle_path: config.ssr_bundle_path,
+          development: development?
+        )
+      end
+    end
+
+    def root
+      config.root
+    end
+
+    def env
+      @env ||= ENV["RACK_ENV"] || ENV["RAILS_ENV"] || "development"
+    end
+
+    def development?
+      env == "development"
+    end
+
+    def production?
+      env == "production"
+    end
+
+    def test?
+      env == "test"
+    end
+  end
+end
+
+require "salvia/railtie" if defined?(Rails)