fusee-framework 1.6.0 → 1.7.0

package/bin/index.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+import { spawn } from 'child_process';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import fs from 'fs';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+function getBinaryName() {
+  const platform = process.platform;
+  const arch = process.arch;
+
+  if (platform === 'win32') return 'create-fusee-win.exe';
+  if (platform === 'darwin') {
+    return arch === 'arm64' ? 'create-fusee-mac-arm64' : 'create-fusee-mac-intel';
+  }
+  if (platform === 'linux') return 'create-fusee-linux';
+  
+  return 'create-fusee-linux'; // Default fallback
+}
+
+const binName = getBinaryName();
+const binPath = path.join(__dirname, binName);
+
+// Fallback for local development if specific named binary isn't there
+const finalPath = fs.existsSync(binPath) ? binPath : path.join(__dirname, 'create-fusee.exe');
+
+if (!fs.existsSync(finalPath)) {
+  console.error(`\n❌ Error: Fusée binary not found for your platform (${process.platform})`);
+  process.exit(1)
+}
+
+const args = process.argv.slice(2);
+const child = spawn(finalPath, args, { stdio: 'inherit' });
+
+child.on('exit', (code) => {
+  process.exit(code);
+});

package/create-fusee-go/cmd/generate.go

@@ -0,0 +1,72 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"create-fusee/internal/assets"
+	"github.com/spf13/cobra"
+)
+
+var genCmd = &cobra.Command{
+	Use:     "generate [type] [name]",
+	Aliases: []string{"g"},
+	Short:   "Generate a new page or component",
+	Long: `Generate a new Fusée resource. 
+Types available: page (p), component (c)`,
+	Args: cobra.ExactArgs(2),
+	Run: func(cmd *cobra.Command, args []string) {
+		genType := strings.ToLower(args[0])
+		name := strings.Title(args[1])
+
+		// Check if we are in a Fusée project
+		if _, err := os.Stat("framework"); os.IsNotExist(err) {
+			fmt.Println("❌ Error: This command must be run from the root of a Fusée project.")
+			os.Exit(1)
+		}
+
+		ext := "js"
+		if _, err := os.Stat("tsconfig.json"); err == nil {
+			ext = "ts"
+		}
+
+		config := assets.Config{
+			ProjectName: name,
+			IsTS:        ext == "ts",
+			Ext:         ext,
+		}
+
+		var dest string
+		var tmpl string
+
+		switch genType {
+		case "page", "p":
+			dest = filepath.Join("app/pages", args[1]+"."+ext)
+			tmpl = "templates/page.tmpl"
+		case "component", "c":
+			dest = filepath.Join("app/components", args[1]+"."+ext)
+			tmpl = "templates/component.tmpl"
+		default:
+			fmt.Printf("❌ Error: Unknown type '%s'. Use 'page' or 'component'.\n", genType)
+			os.Exit(1)
+		}
+
+		if _, err := os.Stat(dest); err == nil {
+			fmt.Printf("❌ Error: File '%s' already exists.\n", dest)
+			os.Exit(1)
+		}
+
+		if err := assets.WriteTemplate(tmpl, dest, config); err != nil {
+			fmt.Printf("❌ Error: Could not generate %s: %v\n", genType, err)
+			os.Exit(1)
+		}
+
+		fmt.Printf("✅ %s created: %s\n", strings.Title(genType), dest)
+	},
+}
+
+func init() {
+	rootCmd.AddCommand(genCmd)
+}

package/create-fusee-go/cmd/init.go

@@ -0,0 +1,38 @@
+package cmd
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"strings"
+
+	"github.com/spf13/cobra"
+)
+
+
+var initCmd = &cobra.Command{
+	Use:   "init [project-name]",
+	Short: "Initialize a new Fusée project",
+	Args:  cobra.MaximumNArgs(1),
+	Run: func(cmd *cobra.Command, args []string) {
+		projectName := "my-fusee-app"
+		if len(args) > 0 {
+			projectName = args[0]
+		}
+		
+		isTS := IsTSFlag
+		if !cmd.Flags().Changed("ts") {
+			reader := bufio.NewReader(os.Stdin)
+			fmt.Printf("🧬 Select language template [JavaScript (js) / TypeScript (ts)] (default: js): ")
+			langInput, _ := reader.ReadString('\n')
+			isTS = strings.TrimSpace(strings.ToLower(langInput)) == "ts"
+		}
+		
+		runInitWithParams(projectName, isTS)
+	},
+}
+
+func init() {
+	initCmd.Flags().BoolVarP(&IsTSFlag, "ts", "t", false, "Use TypeScript template")
+	rootCmd.AddCommand(initCmd)
+}

package/create-fusee-go/cmd/root.go

@@ -0,0 +1,121 @@
+package cmd
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"create-fusee/internal/assets"
+	"github.com/spf13/cobra"
+)
+
+var IsTSFlag bool
+
+var rootCmd = &cobra.Command{
+	Use:   "fusee",
+	Short: "Fusée is a high-performance reactive framework CLI",
+	Long: `Fusée CLI helps you scaffold new projects, generate components, 
+and manage your Fusée application development workflow.`,
+	Args: cobra.MaximumNArgs(1),
+	Run: func(cmd *cobra.Command, args []string) {
+		if len(args) > 0 {
+			isTS := IsTSFlag
+			if !cmd.Flags().Changed("ts") {
+				reader := bufio.NewReader(os.Stdin)
+				fmt.Printf("🧬 Select language template [JavaScript (js) / TypeScript (ts)] (default: js): ")
+				langInput, _ := reader.ReadString('\n')
+				isTS = strings.TrimSpace(strings.ToLower(langInput)) == "ts"
+			}
+			runInitWithParams(args[0], isTS)
+		} else {
+			cmd.Help()
+		}
+	},
+}
+
+func Execute() {
+	if err := rootCmd.Execute(); err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+}
+
+func init() {
+	rootCmd.Flags().BoolVarP(&IsTSFlag, "ts", "t", false, "Use TypeScript template")
+}
+
+func runInitWithParams(projectName string, isTS bool) {
+	if strings.ContainsAny(projectName, " !@#$%^&*()") {
+		fmt.Printf("❌ Error: Project name '%s' contains invalid characters.\n", projectName)
+		os.Exit(1)
+	}
+
+	projectPath, err := filepath.Abs(projectName)
+	if err != nil {
+		fmt.Printf("❌ Error: Could not determine absolute path: %v\n", err)
+		os.Exit(1)
+	}
+
+	if _, err := os.Stat(projectPath); !os.IsNotExist(err) && projectName != "." {
+		fmt.Printf("❌ Error: Directory '%s' already exists.\n", projectName)
+		os.Exit(1)
+	}
+
+	ext := "js"
+	if isTS {
+		ext = "ts"
+	}
+
+	fmt.Printf("\n🚀 Scaffolding a new project in: %s...\n", projectPath)
+
+	config := assets.Config{
+		ProjectName: filepath.Base(projectName),
+		IsTS:        isTS,
+		Ext:         ext,
+		BtnStyle:    "background:#ff3333; color:white; border:none; width:50px; height:50px; border-radius:15px; cursor:pointer; font-size:1.5rem; transition: 0.2s;",
+	}
+	if projectName == "." {
+		config.ProjectName = "fusee-project"
+	}
+
+	dirs := []string{"app/components", "app/pages", "app/routes", "framework"}
+	for _, d := range dirs {
+		if err := os.MkdirAll(filepath.Join(projectPath, d), 0755); err != nil {
+			fmt.Printf("❌ Error: Could not create directory %s: %v\n", d, err)
+			os.Exit(1)
+		}
+	}
+
+	fmt.Println("📦 Injecting Fusée Core Engine...")
+	if err := assets.CopyEmbeddedDir("embed/framework", filepath.Join(projectPath, "framework"), isTS); err != nil {
+		fmt.Printf("❌ Error: Could not inject framework: %v\n", err)
+		os.Exit(1)
+	}
+
+	files := map[string]string{
+		"templates/package.json.tmpl":       "package.json",
+		"templates/vite.config.js.tmpl":     "vite.config.js",
+		"templates/index.html.tmpl":         "index.html",
+		"templates/main.tmpl":               "app/main." + ext,
+		"templates/components/Loading.tmpl": "app/components/Loading." + ext,
+		"templates/pages/layout.tmpl":       "app/pages/_layout." + ext,
+		"templates/pages/index.tmpl":        "app/pages/index." + ext,
+		"templates/pages/about.tmpl":        "app/pages/about." + ext,
+		"templates/Counter.tmpl":            "app/components/Counter." + ext,
+	}
+	if isTS {
+		files["templates/tsconfig.json.tmpl"] = "tsconfig.json"
+	}
+
+	for src, dest := range files {
+		if err := assets.WriteTemplate(src, filepath.Join(projectPath, dest), config); err != nil {
+			fmt.Printf("❌ Error: Could not write file %s: %v\n", dest, err)
+			os.Exit(1)
+		}
+	}
+
+	fmt.Println("\n✅ Fusée Project Ready!")
+	fmt.Printf("👉 Run: cd %s && npm install && npm run dev\n\n", projectName)
+}

package/create-fusee-go/go.mod

@@ -0,0 +1,10 @@
+module create-fusee
+
+go 1.21
+
+require github.com/spf13/cobra v1.8.0
+
+require (
+	github.com/inconshreveable/mousetrap v1.1.0 // indirect
+	github.com/spf13/pflag v1.0.5 // indirect
+)

package/create-fusee-go/go.sum

@@ -0,0 +1,10 @@
+github.com/cpuguy83/go-md2man/v2 v2.0.3/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
+github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
+github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
+github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
+github.com/spf13/cobra v1.8.0 h1:7aJaZx1B85qltLMc546zn58BxxfZdR/W22ej9CFoEf0=
+github.com/spf13/cobra v1.8.0/go.mod h1:WXLWApfZ71AjXPya3WOlMsY9yMs7YeiHhFVlvLyhcho=
+github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
+github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

package/create-fusee-go/internal/assets/assets.go

@@ -0,0 +1,78 @@
+package assets
+
+import (
+	"embed"
+	"io/fs"
+	"os"
+	"path/filepath"
+	"strings"
+	"text/template"
+)
+
+//go:embed all:templates all:embed/framework
+var EmbeddedFiles embed.FS
+
+type Config struct {
+	ProjectName string
+	IsTS        bool
+	Ext         string
+	BtnStyle    string
+}
+
+func CopyEmbeddedDir(srcDir, destDir string, keepTypes bool) error {
+	return fs.WalkDir(EmbeddedFiles, srcDir, func(path string, d fs.DirEntry, err error) error {
+		if err != nil {
+			return err
+		}
+
+		relPath := strings.TrimPrefix(path, srcDir)
+		relPath = strings.TrimPrefix(relPath, "/")
+
+		if relPath == "" {
+			return nil
+		}
+
+		if !keepTypes && (strings.HasSuffix(relPath, ".d.ts") || strings.HasPrefix(relPath, "types")) {
+			return nil
+		}
+
+		parts := strings.Split(relPath, "/")
+		for _, part := range parts {
+			if part == "bin" || part == "node_modules" || part == ".git" || part == "dist" || part == "__tests__" {
+				return nil
+			}
+		}
+
+		destPath := filepath.Join(destDir, filepath.FromSlash(relPath))
+
+		if d.IsDir() {
+			return os.MkdirAll(destPath, 0755)
+		}
+
+		data, err := EmbeddedFiles.ReadFile(path)
+		if err != nil {
+			return err
+		}
+		return os.WriteFile(destPath, data, 0644)
+	})
+}
+
+func WriteTemplate(tmplPath, destPath string, config Config) error {
+	data, err := EmbeddedFiles.ReadFile(tmplPath)
+	if err != nil {
+		return err
+	}
+
+	tmpl, err := template.New(tmplPath).Parse(string(data))
+	if err != nil {
+		return err
+	}
+
+	f, err := os.Create(destPath)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	return tmpl.Execute(f, config)
+}

package/create-fusee-go/internal/assets/embed/framework/auto-import-preset.js

@@ -0,0 +1,9 @@
+export const FuseePreset = {
+    'fusee-framework': [
+        'signal', 'computed', 'effect', 'watch',
+        'batch', 'untrack', 'inspect', 'onCleanup',
+        'defineComponent', 'onMount', 'onUnmount',
+        'directive',
+        'mountOutlet', 'mountTemplate', 'emit'
+    ]
+}

package/create-fusee-go/internal/assets/embed/framework/core/compiler.js

@@ -0,0 +1,253 @@
+import { effect, batch } from './signal.js'
+import { processDirectives } from './directives.js'
+import { parseSlots } from './component.js'
+import {
+    evaluateExpression,
+    parseInterpolation,
+    sanitizeAttr,
+    MUSTACHE_RE
+} from './evaluator.js'
+
+export function mountTemplate(template, container, context, components) {
+    const effects = []
+    let processed = template.replace(/(<[a-zA-Z0-9-]+\s[^>]*?)\s:([a-zA-Z][a-zA-Z0-9-]*)=/g, '$1 data-bind-$2=')
+
+    for (const name of Object.keys(components)) {
+        const reWithSlot = new RegExp(
+            `\\{\\{\\s*${name}(\\s[^}]*?|\\s*)\\}\\}([\\s\\S]*?)\\{\\{\\s*\\/${name}\\s*\\}\\}`,
+            'g'
+        )
+        const reNoSlot = new RegExp(`\\{\\{\\s*${name}(\\s+.*?|\\s*)\\}\\}`, 'g')
+
+        processed = processed.replace(reWithSlot, (match, propsStr, slotContent) => {
+            const attrs = parseComponentAttrs(propsStr || '')
+            const encodedSlot = encodeURIComponent(slotContent.trim())
+            return `<div data-component="${name}"${attrs} data-slot="${encodedSlot}"></div>`
+        })
+
+        processed = processed.replace(reNoSlot, (match, propsStr) => {
+            const attrs = parseComponentAttrs(propsStr || '')
+            return `<div data-component="${name}"${attrs}></div>`
+        })
+    }
+
+    container.innerHTML = processed
+    compileNode(container, context, components, effects)
+
+    return { effects }
+}
+
+function parseComponentAttrs(propsStr) {
+    let attrs = ''
+    if (!propsStr || !propsStr.trim()) return attrs
+
+    const attrRegex = /(@?:?[a-zA-Z0-9-]+)="([^"]*)"/g
+    let attrMatch
+    while ((attrMatch = attrRegex.exec(propsStr)) !== null) {
+        const attrName = attrMatch[1]
+        const attrValue = attrMatch[2]
+
+        if (attrName.startsWith('@')) {
+            attrs += ` data-on-${attrName.slice(1).toLowerCase()}="${attrValue}"`
+        } else if (attrName.startsWith(':')) {
+            attrs += ` data-bind-prop-${attrName.slice(1).toLowerCase()}="${attrValue}"`
+        } else {
+            attrs += ` data-prop-${attrName.toLowerCase()}="${attrValue}"`
+        }
+    }
+    return attrs
+}
+
+export function compileNode(node, context, components, effects) {
+    if (node.nodeType === 1 && node.hasAttribute('f-once')) {
+        node.removeAttribute('f-once')
+        const temporaryEffects = []
+
+        processDirectives(node, context, components, temporaryEffects)
+        processBindingAttrs(node, context, temporaryEffects)
+        processMustaches(node, context, temporaryEffects)
+        bindComponents(node, components, context, temporaryEffects)
+
+        let child = node.firstChild
+        while (child) {
+            compileOnce(child, context, components, temporaryEffects)
+            child = child.nextSibling
+        }
+
+        for (let i = temporaryEffects.length - 1; i >= 0; i--) {
+            const cleanup = temporaryEffects[i]
+            if (typeof cleanup === 'function') cleanup()
+        }
+        return
+    }
+
+    if (node.nodeType === 1) {
+        if (processDirectives(node, context, components, effects)) return
+        processBindingAttrs(node, context, effects)
+        bindComponents(node, components, context, effects)
+    } else if (node.nodeType === 3) {
+        processMustaches(node, context, effects)
+    }
+
+    let child = node.firstChild
+    while (child) {
+        compileNode(child, context, components, effects)
+        child = child.nextSibling
+    }
+}
+
+function compileOnce(node, context, components, effects) {
+    if (node.nodeType === 1) {
+        if (processDirectives(node, context, components, effects)) return
+        processBindingAttrs(node, context, effects)
+        bindComponents(node, components, context, effects)
+    } else if (node.nodeType === 3) {
+        processMustaches(node, context, effects)
+    }
+
+    let child = node.firstChild
+    while (child) {
+        compileOnce(child, context, components, effects)
+        child = child.nextSibling
+    }
+}
+
+function processMustaches(node, context, effects) {
+    if (node.nodeType !== 3) return
+    const text = node.textContent
+    if (!MUSTACHE_RE.test(text)) return
+
+    const parts = parseInterpolation(text)
+    const fragment = document.createDocumentFragment()
+
+    for (const part of parts) {
+        if (part.type === 'static') {
+            fragment.appendChild(document.createTextNode(part.value))
+        } else {
+            const reactiveNode = document.createTextNode('')
+            fragment.appendChild(reactiveNode)
+            const key = part.key
+            const e = effect(() => {
+                const resolved = evaluateExpression(key, context)
+                reactiveNode.textContent = String(resolved ?? '')
+            })
+            effects.push(e)
+        }
+    }
+    node.parentNode.replaceChild(fragment, node)
+}
+
+function processBindingAttrs(el, context, effects) {
+    if (el.nodeType !== 1) return
+    for (const attr of [...el.attributes]) {
+        if (attr.name.startsWith('data-bind-') && !attr.name.startsWith('data-bind-prop-')) {
+            const realAttr = attr.name.slice(10)
+            const expr = attr.value
+            el.removeAttribute(attr.name)
+
+            const e = effect(() => {
+                let resolved = evaluateExpression(expr, context)
+                if (realAttr === 'class') {
+                    if (!el._staticClass) el._staticClass = el.getAttribute('class') || ''
+                    let dynamicClass = ''
+                    if (Array.isArray(resolved)) dynamicClass = resolved.filter(Boolean).join(' ')
+                    else if (resolved !== null && typeof resolved === 'object') {
+                        dynamicClass = Object.entries(resolved).filter(([_, v]) => !!v).map(([k]) => k).join(' ')
+                    } else dynamicClass = String(resolved ?? '')
+                    el.className = (el._staticClass + ' ' + dynamicClass).trim()
+                } else if (realAttr === 'style') {
+                    if (resolved !== null && typeof resolved === 'object') {
+                        for (const k in resolved) el.style[k] = resolved[k]
+                    } else el.style.cssText = String(resolved ?? '')
+                } else {
+                    if (typeof resolved === 'boolean') {
+                        resolved ? el.setAttribute(realAttr, '') : el.removeAttribute(realAttr)
+                    } else el.setAttribute(realAttr, sanitizeAttr(realAttr, String(resolved)))
+                }
+            })
+            effects.push(e)
+            continue
+        }
+
+        if (MUSTACHE_RE.test(attr.value)) {
+            const attrName = attr.name
+            const parts = parseInterpolation(attr.value)
+            el.removeAttribute(attrName)
+            const e = effect(() => {
+                let result = ''
+                for (const part of parts) {
+                    result += part.type === 'static' ? part.value : String(evaluateExpression(part.key, context) ?? '')
+                }
+                el.setAttribute(attrName, sanitizeAttr(attrName, result))
+            })
+            effects.push(e)
+        }
+    }
+}
+
+function bindComponents(el, components, context, effects) {
+    if (el.nodeType !== 1) return
+    const name = el.getAttribute('data-component')
+    if (!name) return
+
+    el.removeAttribute('data-component')
+
+    const ComponentFn = components[name]
+    if (!ComponentFn) return
+
+    const props = {}
+    const listeners = {}
+
+    for (const attr of [...el.attributes]) {
+        const attrName = attr.name.toLowerCase()
+
+        if (attrName.startsWith('data-prop-')) {
+            props[attrName.slice(10)] = attr.value
+
+        } else if (attrName.startsWith('data-bind-prop-')) {
+            const propName = attrName.slice(15)
+            const expression = attr.value.trim()
+
+            if (expression in context) {
+                Object.defineProperty(props, propName, {
+                    get() {
+                        const val = context[expression]
+                        return typeof val === 'function' && val.isSignal ? val() : val
+                    },
+                    enumerable: true,
+                    configurable: true
+                })
+            } else {
+                Object.defineProperty(props, propName, {
+                    get() { return evaluateExpression(expression, context) },
+                    enumerable: true,
+                    configurable: true
+                })
+            }
+
+        } else if (attrName.startsWith('data-on-')) {
+            const eventName = attrName.slice(8)
+            const handlerExpr = attr.value.trim()
+
+            listeners[eventName] = (...args) => {
+                const handler = context[handlerExpr]
+                if (typeof handler === 'function') {
+                    handler(...args)
+                } else {
+                    evaluateExpression(handlerExpr, context)
+                }
+            }
+        }
+    }
+
+    const rawSlot = el.getAttribute('data-slot')
+    const slots = rawSlot ? parseSlots(decodeURIComponent(rawSlot)) : {}
+    el.removeAttribute('data-slot')
+
+    const childComponent = ComponentFn(props, { listeners, slots, parent: context._instance })
+    childComponent.render(el)
+
+    if (effects) {
+        effects.push(() => childComponent.unmount())
+    }
+}