salvia 0.2.0

data/assets/scripts/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/assets/scripts/vendor_setup.ts

@@ -0,0 +1,25 @@
+import { h, Fragment } from "preact";
+import * as preact from "preact";
+import * as hooks from "preact/hooks";
+import * as signals from "@preact/signals";
+import * as jsxRuntime from "preact/jsx-runtime";
+import { renderToString } from "preact-render-to-string";
+
+// Expose to global scope for JIT bundles (IIFE)
+(globalThis as any).Preact = preact;
+(globalThis as any).PreactHooks = hooks;
+(globalThis as any).PreactSignals = signals;
+(globalThis as any).PreactJsxRuntime = jsxRuntime;
+(globalThis as any).renderToString = renderToString;
+(globalThis as any).h = h;
+(globalThis as any).Fragment = Fragment;
+
+// Simple require shim for JIT bundles
+(globalThis as any).require = function(moduleName: string) {
+  if (moduleName === "preact") return preact;
+  if (moduleName === "preact/hooks") return hooks;
+  if (moduleName === "@preact/signals") return signals;
+  if (moduleName === "preact/jsx-runtime") return jsxRuntime;
+  if (moduleName === "preact-render-to-string") return { default: renderToString, renderToString };
+  throw new Error("Module not found: " + moduleName);
+};

data/exe/salvia

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "salvia"
+require "salvia/cli"
+
+Salvia::CLI.start(ARGV)
+

data/lib/salvia/cli.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require "thor"
+require "fileutils"
+
+module Salvia
+  class CLI < Thor
+    include Thor::Actions
+
+    def self.source_root
+      File.expand_path("../../..", __FILE__)
+    end
+
+    desc "install", "Install Salvia SSR files into your application"
+    def install
+      say "🌿 Salvia Installer", :bold
+      say "===================", :bold
+      say ""
+
+      # 1. Backend Framework
+      backend = if File.exist?("bin/rails") || File.exist?("config/application.rb")
+                  "rails"
+                else
+                  "other"
+                end
+
+      # 2. Tailwind CSS
+      install_tailwind = yes?("1. Do you want to install Tailwind CSS (via tailwindcss-ruby)? (y/N)", :yellow)
+
+      say ""
+      say "🚀 Installing Salvia (Preact + Signals) for #{backend}...", :green
+      say ""
+
+      # Create directories
+      empty_directory "salvia/app/islands"
+      empty_directory "salvia/app/pages"
+      empty_directory "salvia/app/components"
+      empty_directory "public/assets/javascripts"
+      empty_directory "public/assets/islands"
+      empty_directory "salvia"
+
+      # Copy files
+      # Note: source_root is 'salvia/', so paths are relative to that
+      copy_file "assets/scripts/deno.json", "salvia/deno.json"
+      copy_file "assets/components/Island.tsx", "salvia/app/components/Island.tsx"
+      copy_file "assets/islands/Counter.tsx", "salvia/app/islands/Counter.tsx"
+      copy_file "assets/pages/Home.tsx", "salvia/app/pages/Home.tsx"
+      
+      create_file "salvia/.gitignore", "/server/\n"
+
+      # Backend Setup
+      case backend
+      when "rails"
+        create_file "config/initializers/salvia.rb" do
+          <<~RUBY
+            Salvia.configure do |config|
+              config.islands_dir = Rails.root.join("salvia/app/islands")
+              config.build_dir = Rails.root.join("public/assets")
+              config.ssr_bundle_path = Rails.root.join("salvia/server/ssr_bundle.js")
+            end
+            
+            # Initialize SSR Engine
+            Salvia::SSR.configure(
+              bundle_path: Salvia.config.ssr_bundle_path,
+              development: Rails.env.development?
+            )
+          RUBY
+        end
+        say "   - Created config/initializers/salvia.rb"
+      end
+
+      # Tailwind CSS Setup
+      if install_tailwind
+        # Add tailwindcss-ruby to Gemfile if present
+        if File.exist?("Gemfile")
+          unless File.read("Gemfile").include?("tailwindcss-ruby")
+            append_to_file "Gemfile", "\ngem 'tailwindcss-ruby'\n"
+            say "   - Added 'tailwindcss-ruby' to Gemfile"
+          end
+        end
+
+        empty_directory "app/assets/stylesheets"
+        create_file "app/assets/stylesheets/application.tailwind.css" do
+          <<~CSS
+            @import "tailwindcss";
+
+            @source "../../views/**/*.erb";
+            @source "../../islands/**/*.{js,jsx,tsx}";
+            @source "../../../public/assets/javascripts/**/*.js";
+
+            @theme {
+              --color-salvia-500: #6A5ACD;
+              --color-salvia-600: #5a4ab8;
+            }
+          CSS
+        end
+        
+        say "   - app/assets/stylesheets/ : Tailwind CSS entry point created (v4)"
+      end
+
+      say ""
+      say "✅ Salvia SSR installed!", :green
+      say "   - salvia/app/islands/    : Put your interactive Island components here"
+      say "   - salvia/app/pages/      : Put your static Server Components here (JS-free)"
+      say "   - salvia/app/components/ : Put your shared/static components here"
+      say ""
+      say "Next steps:", :yellow
+      say "  1. Install Deno: https://deno.land"
+      if install_tailwind
+        say "  2. Run 'bundle install' to install Tailwind"
+        say "  3. Run build: salvia build"
+        say "  4. Watch assets: bundle exec foreman start -f Procfile.dev (recommended)"
+      else
+        say "  2. Run build: salvia build"
+      end
+    end
+
+    desc "build", "Build Island components for SSR"
+    method_option :verbose, aliases: "-v", type: :boolean, default: false, desc: "Verbose output"
+    def build
+      check_deno_installed!
+      
+      say "🏝️  Building Island components...", :green
+      
+      # Use internal build script
+      build_script = File.expand_path("../../../assets/scripts/build.ts", __FILE__)
+      
+      # Use user's deno.json if available, otherwise fallback to internal
+      user_config = File.expand_path("salvia/deno.json")
+      config_path = if File.exist?(user_config)
+                      user_config
+                    else
+                      File.expand_path("../../../assets/scripts/deno.json", __FILE__)
+                    end
+      
+      cmd = "deno run --allow-all --config #{config_path} #{build_script}"
+      cmd += " --verbose" if options[:verbose]
+      
+      success = system(cmd)
+      
+      if success
+        say "✅ SSR build completed!", :green
+      else
+        say "❌ SSR build failed", :red
+        exit 1
+      end
+    end
+
+    desc "watch", "Watch and rebuild Island components"
+    method_option :verbose, aliases: "-v", type: :boolean, default: false, desc: "Verbose output"
+    def watch
+      check_deno_installed!
+      
+      say "👀 Watching Island components...", :green
+      
+      # Use internal build script
+      build_script = File.expand_path("../../../assets/scripts/build.ts", __FILE__)
+      
+      # Use user's deno.json if available, otherwise fallback to internal
+      user_config = File.expand_path("salvia/deno.json")
+      config_path = if File.exist?(user_config)
+                      user_config
+                    else
+                      File.expand_path("../../../assets/scripts/deno.json", __FILE__)
+                    end
+      
+      cmd = "deno run --allow-all --config #{config_path} #{build_script} --watch"
+      cmd += " --verbose" if options[:verbose]
+      
+      exec cmd
+    end
+
+    desc "version", "Display Salvia version"
+    def version
+      require "salvia/version"
+      say "Salvia #{Salvia::VERSION}"
+    end
+
+    private
+
+    def check_deno_installed!
+      unless system("which deno > /dev/null 2>&1")
+        say "❌ Deno is not installed.", :red
+        say "Please install Deno: https://deno.land", :yellow
+        exit 1
+      end
+    end
+  end
+end

data/lib/salvia/compiler/adapters/deno_sidecar.rb

@@ -0,0 +1,23 @@
+module Salvia
+  class Compiler
+    module Adapters
+      class DenoSidecar
+        def bundle(entry_point, **options)
+          Salvia::Server::Sidecar.instance.bundle(entry_point, **options)
+        end
+
+        def check(entry_point, **options)
+          Salvia::Server::Sidecar.instance.check(entry_point, **options)
+        end
+
+        def fmt(entry_point, **options)
+          Salvia::Server::Sidecar.instance.fmt(entry_point, **options)
+        end
+
+        def shutdown
+          Salvia::Server::Sidecar.instance.stop
+        end
+      end
+    end
+  end
+end

data/lib/salvia/compiler.rb

@@ -0,0 +1,29 @@
+module Salvia
+  class Compiler
+    class Error < Salvia::Error; end
+
+    class << self
+      attr_writer :adapter
+
+      def adapter
+        @adapter ||= Salvia::Compiler::Adapters::DenoSidecar.new
+      end
+
+      def bundle(entry_point, **options)
+        adapter.bundle(entry_point, **options)
+      end
+
+      def check(entry_point)
+        adapter.check(entry_point)
+      end
+
+      def fmt(entry_point)
+        adapter.fmt(entry_point)
+      end
+
+      def shutdown
+        adapter.shutdown if adapter.respond_to?(:shutdown)
+      end
+    end
+  end
+end

data/lib/salvia/core/configuration.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Salvia
+  module Core
+    class Configuration
+      attr_accessor :ssr_bundle_path, :island_inspector, :islands_dir, :build_dir, :deno_config_path, :root
+
+      def initialize
+        @root = Dir.pwd
+        @ssr_bundle_path = "salvia/server/ssr_bundle.js"
+        @islands_dir = "salvia/app/islands"
+        @build_dir = "public/assets"
+        
+        user_deno_json = File.join(@root, "salvia/deno.json")
+        if File.exist?(user_deno_json)
+          @deno_config_path = user_deno_json
+        else
+          @deno_config_path = File.expand_path("../../../assets/scripts/deno.json", __dir__)
+        end
+        
+        @island_inspector = nil
+      end
+
+      def island_inspector?
+        return @island_inspector unless @island_inspector.nil?
+        Salvia.development?
+      end
+    end
+  end
+end

data/lib/salvia/core/error.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Salvia
+  module Core
+    class Error < StandardError; end
+  end
+end

data/lib/salvia/core/import_map.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Salvia
+  module Core
+    class ImportMap
+    def self.load
+      new.load
+    end
+
+    def load
+      path = find_deno_json
+      return {} unless path
+
+      begin
+        content = File.read(path)
+        json = JSON.parse(content)
+        json["imports"] || {}
+      rescue JSON::ParserError
+        {}
+      end
+    end
+
+    def keys
+      load.keys
+    end
+
+    private
+
+    def find_deno_json
+      Salvia.config.deno_config_path
+    end
+    end
+  end
+end

data/lib/salvia/core/path_resolver.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Salvia
+  module Core
+    class PathResolver
+    def self.resolve(name)
+      # Check flat structure
+      path = File.join(Salvia.root, "#{name}.tsx")
+      return path if File.exist?(path)
+
+      roots = [
+        "salvia/app/pages",
+        "salvia/app/islands",
+        "salvia/app/components"
+      ]
+      
+      roots.each do |root|
+        path = File.join(Salvia.root, root, "#{name}.tsx")
+        return path if File.exist?(path)
+        
+        path = File.join(Salvia.root, root, "#{name}.jsx")
+        return path if File.exist?(path)
+        
+        path = File.join(Salvia.root, root, "#{name}.js")
+        return path if File.exist?(path)
+      end
+      
+      if name.include?("/")
+         path = File.join(Salvia.root, "salvia/app", "#{name}.tsx")
+         return path if File.exist?(path)
+         
+         path = File.join(Salvia.root, "salvia/app", "#{name}.jsx")
+         return path if File.exist?(path)
+         
+         path = File.join(Salvia.root, "salvia/app", "#{name}.js")
+         return path if File.exist?(path)
+      end
+      
+      nil
+    end
+    end
+  end
+end