fusee-framework 2.7.0 → 2.7.2

package/framework/engine-go/router.go

@@ -1,85 +0,0 @@
-package engine
-
-import (
-	"net/url"
-	"regexp"
-	"strings"
-)
-
-type paramSpec struct {
-	name     string
-	catchAll bool
-}
-
-type Route struct {
-	Pattern string
-	Handler any
-	regex   *regexp.Regexp
-	params  []paramSpec
-}
-
-func Compile(pattern string, handler any) *Route {
-	segments := strings.Split(strings.Trim(pattern, "/"), "/")
-	var params []paramSpec
-	var body strings.Builder
-
-	for _, seg := range segments {
-		if seg == "" {
-			continue
-		}
-		switch {
-		case strings.HasPrefix(seg, "[...") && strings.HasSuffix(seg, "]"):
-			name := seg[4 : len(seg)-1]
-			params = append(params, paramSpec{name: name, catchAll: true})
-			body.WriteString(`/(.+)`)
-		case strings.HasPrefix(seg, "[") && strings.HasSuffix(seg, "]"):
-			name := seg[1 : len(seg)-1]
-			params = append(params, paramSpec{name: name})
-			body.WriteString(`/([^/]+)`)
-		default:
-			body.WriteString("/" + regexp.QuoteMeta(seg))
-		}
-	}
-
-	pat := body.String()
-	if pat == "" {
-		pat = "/"
-	}
-
-	return &Route{
-		Pattern: pattern,
-		Handler: handler,
-		regex:   regexp.MustCompile("^" + pat + "/?$"),
-		params:  params,
-	}
-}
-
-type Match struct {
-	Route  *Route
-	Params map[string]string
-}
-
-func MatchAll(routes []*Route, path string) *Match {
-	if path == "" {
-		path = "/"
-	}
-	for _, r := range routes {
-		m := r.regex.FindStringSubmatch(path)
-		if m == nil {
-			continue
-		}
-		params := make(map[string]string, len(r.params))
-		for i, spec := range r.params {
-			raw := m[i+1]
-			if spec.catchAll {
-				params[spec.name] = raw
-			} else if decoded, err := url.QueryUnescape(raw); err == nil {
-				params[spec.name] = decoded
-			} else {
-				params[spec.name] = raw
-			}
-		}
-		return &Match{Route: r, Params: params}
-	}
-	return nil
-}

package/framework/engine-go/rustast/rustast.go

@@ -1,317 +0,0 @@
-// Package rustast contains Go types that mirror the Fusée Rust compiler's AST.
-// These are used to deserialize the JSON produced by the `fusee-ast` binary.
-//
-// The Rust side uses `#[serde(tag = "type")]` on tagged-union enums, which
-// flattens the variant fields into the same JSON object as the "type" field.
-// Custom UnmarshalJSON implementations here exploit exactly that: peek "type",
-// then unmarshal the whole payload into the matching struct (unknown fields
-// like "type" itself are silently ignored by encoding/json).
-package rustast
-
-import (
-	"encoding/json"
-	"fmt"
-)
-
-type Pos struct {
-	Line   int `json:"line"`
-	Col    int `json:"col"`
-	Offset int `json:"offset"`
-}
-
-type Loc struct {
-	Start Pos `json:"start"`
-	End   Pos `json:"end"`
-}
-
-type Expression struct {
-	Content  string `json:"content"`
-	IsStatic bool   `json:"is_static"`
-	IsForKey bool   `json:"is_for_key"`
-	Loc      Loc    `json:"loc"`
-}
-
-type AttributeNode struct {
-	Name  string  `json:"name"`
-	Value *string `json:"value"`
-	Loc   Loc     `json:"loc"`
-}
-
-type BindingNode struct {
-	Name       string     `json:"name"`
-	Expression Expression `json:"expression"`
-	IsProp     bool       `json:"is_prop"`
-	Loc        Loc        `json:"loc"`
-}
-
-type EventNode struct {
-	Name       string     `json:"name"`
-	Expression Expression `json:"expression"`
-	Modifiers  []string   `json:"modifiers"`
-	Loc        Loc        `json:"loc"`
-}
-
-type ForArg struct {
-	Item   string  `json:"item"`
-	Source string  `json:"source"`
-	Index  *string `json:"index"`
-	Loc    Loc     `json:"loc"`
-}
-
-type DirectiveNode struct {
-	Name       string      `json:"name"`
-	Expression *Expression `json:"expression"`
-	Arg        *ForArg     `json:"arg"`
-	Loc        Loc         `json:"loc"`
-}
-
-type PropType string
-
-const (
-	PropAttribute PropType = "Attribute"
-	PropBinding   PropType = "Binding"
-	PropEvent     PropType = "Event"
-	PropDirective PropType = "Directive"
-)
-
-type Prop struct {
-	Type      PropType
-	Attribute *AttributeNode
-	Binding   *BindingNode
-	Event     *EventNode
-	Directive *DirectiveNode
-}
-
-func (p *Prop) UnmarshalJSON(data []byte) error {
-	var probe struct {
-		Type PropType `json:"type"`
-	}
-	if err := json.Unmarshal(data, &probe); err != nil {
-		return err
-	}
-	p.Type = probe.Type
-	switch probe.Type {
-	case PropAttribute:
-		p.Attribute = &AttributeNode{}
-		return json.Unmarshal(data, p.Attribute)
-	case PropBinding:
-		p.Binding = &BindingNode{}
-		return json.Unmarshal(data, p.Binding)
-	case PropEvent:
-		p.Event = &EventNode{}
-		return json.Unmarshal(data, p.Event)
-	case PropDirective:
-		p.Directive = &DirectiveNode{}
-		return json.Unmarshal(data, p.Directive)
-	default:
-		return fmt.Errorf("rustast: unknown Prop type %q", probe.Type)
-	}
-}
-
-func (p Prop) MarshalJSON() ([]byte, error) {
-	switch p.Type {
-	case PropAttribute:
-		return marshalTagged("Attribute", p.Attribute)
-	case PropBinding:
-		return marshalTagged("Binding", p.Binding)
-	case PropEvent:
-		return marshalTagged("Event", p.Event)
-	case PropDirective:
-		return marshalTagged("Directive", p.Directive)
-	default:
-		return nil, fmt.Errorf("rustast: unknown Prop type %q", p.Type)
-	}
-}
-
-func marshalTagged(typeName string, v any) ([]byte, error) {
-	inner, err := json.Marshal(v)
-	if err != nil {
-		return nil, err
-	}
-	var m map[string]json.RawMessage
-	if err := json.Unmarshal(inner, &m); err != nil {
-		return nil, err
-	}
-	m["type"] = json.RawMessage(`"` + typeName + `"`)
-	return json.Marshal(m)
-}
-
-type NodeType string
-
-const (
-	NodeRoot          NodeType = "Root"
-	NodeElement       NodeType = "Element"
-	NodeComponent     NodeType = "Component"
-	NodeText          NodeType = "Text"
-	NodeInterpolation NodeType = "Interpolation"
-	NodeSlotOutlet    NodeType = "SlotOutlet"
-	NodeSlotContent   NodeType = "SlotContent"
-	NodeIf            NodeType = "If"
-)
-
-type RootNode struct {
-	Children []*Node `json:"children"`
-	Hoisted  []int   `json:"hoisted"`
-	Loc      Loc     `json:"loc"`
-}
-
-type ElementNode struct {
-	ID          int     `json:"id"`
-	Tag         string  `json:"tag"`
-	Props       []*Prop `json:"props"`
-	Children    []*Node `json:"children"`
-	SelfClosing bool    `json:"self_closing"`
-	IsStatic    bool    `json:"is_static"`
-	Hoisted     bool    `json:"hoisted"`
-	Loc         Loc     `json:"loc"`
-}
-
-type SlotEntry struct {
-	Name     string
-	Children []*Node
-}
-
-func (s *SlotEntry) UnmarshalJSON(data []byte) error {
-	var tuple [2]json.RawMessage
-	if err := json.Unmarshal(data, &tuple); err != nil {
-		return fmt.Errorf("rustast: slot entry is not a 2-element array: %w", err)
-	}
-	if err := json.Unmarshal(tuple[0], &s.Name); err != nil {
-		return err
-	}
-	return json.Unmarshal(tuple[1], &s.Children)
-}
-
-func (s SlotEntry) MarshalJSON() ([]byte, error) {
-	return json.Marshal([2]any{s.Name, s.Children})
-}
-
-type ComponentNode struct {
-	ID    int          `json:"id"`
-	Name  string       `json:"name"`
-	Props []*Prop      `json:"props"`
-	Slots []*SlotEntry `json:"slots"`
-	Loc   Loc          `json:"loc"`
-}
-
-func (c *ComponentNode) Slot(name string) []*Node {
-	for _, s := range c.Slots {
-		if s.Name == name {
-			return s.Children
-		}
-	}
-	return nil
-}
-
-type TextNode struct {
-	Content  string `json:"content"`
-	IsStatic bool   `json:"is_static"`
-	Loc      Loc    `json:"loc"`
-}
-
-type InterpolationNode struct {
-	Expression Expression `json:"expression"`
-	IsStatic   bool       `json:"is_static"`
-	Loc        Loc        `json:"loc"`
-}
-
-type SlotOutletNode struct {
-	SlotName string  `json:"slot_name"`
-	Fallback []*Node `json:"fallback"`
-	Loc      Loc     `json:"loc"`
-}
-
-type SlotContentNode struct {
-	SlotName string  `json:"slot_name"`
-	Children []*Node `json:"children"`
-	Loc      Loc     `json:"loc"`
-}
-
-type Branch struct {
-	Condition *Expression `json:"condition"`
-	Node      *Node       `json:"node"`
-}
-
-type IfNode struct {
-	Branches []Branch `json:"branches"`
-	Loc      Loc      `json:"loc"`
-}
-
-type Node struct {
-	Type NodeType
-
-	Root          *RootNode
-	Element       *ElementNode
-	Component     *ComponentNode
-	Text          *TextNode
-	Interpolation *InterpolationNode
-	SlotOutlet    *SlotOutletNode
-	SlotContent   *SlotContentNode
-	If            *IfNode
-}
-
-func (n *Node) UnmarshalJSON(data []byte) error {
-	var probe struct {
-		Type NodeType `json:"type"`
-	}
-	if err := json.Unmarshal(data, &probe); err != nil {
-		return err
-	}
-	n.Type = probe.Type
-	switch probe.Type {
-	case NodeRoot:
-		n.Root = &RootNode{}
-		return json.Unmarshal(data, n.Root)
-	case NodeElement:
-		n.Element = &ElementNode{}
-		return json.Unmarshal(data, n.Element)
-	case NodeComponent:
-		n.Component = &ComponentNode{}
-		return json.Unmarshal(data, n.Component)
-	case NodeText:
-		n.Text = &TextNode{}
-		return json.Unmarshal(data, n.Text)
-	case NodeInterpolation:
-		n.Interpolation = &InterpolationNode{}
-		return json.Unmarshal(data, n.Interpolation)
-	case NodeSlotOutlet:
-		n.SlotOutlet = &SlotOutletNode{}
-		return json.Unmarshal(data, n.SlotOutlet)
-	case NodeSlotContent:
-		n.SlotContent = &SlotContentNode{}
-		return json.Unmarshal(data, n.SlotContent)
-	case NodeIf:
-		n.If = &IfNode{}
-		return json.Unmarshal(data, n.If)
-	default:
-		return fmt.Errorf("rustast: unknown Node type %q", probe.Type)
-	}
-}
-
-func (n *Node) Props() []*Prop {
-	switch n.Type {
-	case NodeElement:
-		return n.Element.Props
-	case NodeComponent:
-		return n.Component.Props
-	}
-	return nil
-}
-
-func (n *Node) FindDirective(name string) *DirectiveNode {
-	for _, p := range n.Props() {
-		if p.Type == PropDirective && p.Directive.Name == name {
-			return p.Directive
-		}
-	}
-	return nil
-}
-
-// ParseAST deserializes a fusee-ast JSON payload into a Node tree.
-func ParseAST(data []byte) (*Node, error) {
-	var n Node
-	if err := json.Unmarshal(data, &n); err != nil {
-		return nil, fmt.Errorf("rustast: failed to parse AST JSON: %w", err)
-	}
-	return &n, nil
-}

package/framework/engine-go/ssr.go

@@ -1,103 +0,0 @@
-package engine
-
-import (
-	"fmt"
-	"net/http"
-)
-
-type boundary struct {
-	id       string
-	resultCh chan string
-}
-
-type BoundaryRegistry struct {
-	boundaries []*boundary
-}
-
-func NewBoundaryRegistry() *BoundaryRegistry {
-	return &BoundaryRegistry{}
-}
-
-func (b *BoundaryRegistry) RegisterBoundary(id, fallback string, work func() string) string {
-	bd := &boundary{id: id, resultCh: make(chan string, 1)}
-	b.boundaries = append(b.boundaries, bd)
-
-	go func() {
-		bd.resultCh <- work()
-	}()
-
-	return fmt.Sprintf(`<div id="%s" data-f-boundary>%s</div>`, id, fallback)
-}
-
-func renderBoundaryChunk(id, html string) string {
-	tplID := "tpl-" + id
-	return fmt.Sprintf(
-		`<template id="%s">%s</template><script>(function(){var t=document.getElementById(%q);var d=document.getElementById(%q);if(t&&d&&d.parentNode){d.replaceWith(t.content);t.remove();}var s=document.currentScript;if(s&&s.parentNode)s.parentNode.removeChild(s);})();</script>`,
-		tplID, html, tplID, id,
-	)
-}
-
-func RenderPageToStream(w http.ResponseWriter, headers http.Header, shell func(*BoundaryRegistry) string, tail func() string) error {
-	for k, vs := range headers {
-		for _, v := range vs {
-			w.Header().Add(k, v)
-		}
-	}
-	w.WriteHeader(http.StatusOK)
-
-	flusher, ok := w.(http.Flusher)
-	if !ok {
-		return fmt.Errorf("ssr: ResponseWriter does not support flushing (http.Flusher)")
-	}
-
-	registry := NewBoundaryRegistry()
-	shellHTML := shell(registry)
-
-	if _, err := w.Write([]byte(shellHTML)); err != nil {
-		return err
-	}
-	flusher.Flush()
-
-	if err := flushBoundariesOutOfOrder(w, flusher, registry.boundaries); err != nil {
-		return err
-	}
-
-	if tail != nil {
-		if _, err := w.Write([]byte(tail())); err != nil {
-			return err
-		}
-		flusher.Flush()
-	}
-
-	return nil
-}
-
-func flushBoundariesOutOfOrder(w http.ResponseWriter, flusher http.Flusher, boundaries []*boundary) error {
-	if len(boundaries) == 0 {
-		return nil
-	}
-
-	type result struct {
-		id   string
-		html string
-	}
-	done := make(chan result, len(boundaries))
-
-	for _, b := range boundaries {
-		b := b
-		go func() {
-			html := <-b.resultCh
-			done <- result{id: b.id, html: html}
-		}()
-	}
-
-	for i := 0; i < len(boundaries); i++ {
-		r := <-done
-		if _, err := w.Write([]byte(renderBoundaryChunk(r.id, r.html))); err != nil {
-			return err
-		}
-		flusher.Flush()
-	}
-
-	return nil
-}

package/framework/engine-go/static-assets.go

@@ -1,139 +0,0 @@
-package engine
-
-import (
-	"compress/gzip"
-	"io"
-	"net/http"
-	"os"
-	"path/filepath"
-	"regexp"
-	"strings"
-)
-
-var hashedAssetRE = regexp.MustCompile(`[.\-][a-f0-9]{8,}\.[a-zA-Z0-9]+$`)
-
-var mimeTypes = map[string]string{
-	".html":  "text/html; charset=utf-8",
-	".js":    "text/javascript; charset=utf-8",
-	".mjs":   "text/javascript; charset=utf-8",
-	".css":   "text/css; charset=utf-8",
-	".json":  "application/json; charset=utf-8",
-	".svg":   "image/svg+xml",
-	".png":   "image/png",
-	".jpg":   "image/jpeg",
-	".jpeg":  "image/jpeg",
-	".gif":   "image/gif",
-	".webp":  "image/webp",
-	".ico":   "image/x-icon",
-	".woff":  "font/woff",
-	".woff2": "font/woff2",
-	".txt":   "text/plain; charset=utf-8",
-	".map":   "application/json; charset=utf-8",
-	".wasm":  "application/wasm",
-}
-
-func contentTypeFor(path string) string {
-	if ct, ok := mimeTypes[strings.ToLower(filepath.Ext(path))]; ok {
-		return ct
-	}
-	return "application/octet-stream"
-}
-
-func cacheControlFor(path string) string {
-	if hashedAssetRE.MatchString(path) {
-		return "public, max-age=31536000, immutable"
-	}
-	return "public, max-age=0, must-revalidate"
-}
-
-func pickEncoding(acceptEncoding string) string {
-	lower := strings.ToLower(acceptEncoding)
-	if strings.Contains(lower, "br") {
-		return "br"
-	}
-	if strings.Contains(lower, "gzip") {
-		return "gzip"
-	}
-	return ""
-}
-
-func Resolve(distDir, pathname string) (path string, ok bool) {
-	if idx := strings.IndexByte(pathname, '?'); idx != -1 {
-		pathname = pathname[:idx]
-	}
-
-	cleanRel := filepath.Clean(strings.TrimPrefix(pathname, "/"))
-	if cleanRel == "." || cleanRel == "" {
-		return "", false
-	}
-
-	resolvedRoot, err := filepath.Abs(distDir)
-	if err != nil {
-		return "", false
-	}
-
-	// 1. Check in distDir (e.g. dist/assets/...)
-	candidate := filepath.Join(resolvedRoot, cleanRel)
-	if candidate == resolvedRoot || strings.HasPrefix(candidate, resolvedRoot+string(filepath.Separator)) {
-		if info, err := os.Stat(candidate); err == nil && !info.IsDir() {
-			return candidate, true
-		}
-	}
-
-	// 2. Fallback to parent project root (for /app/..., /framework/..., /fusee-logo.svg)
-	projectRoot := filepath.Dir(resolvedRoot)
-	candidateParent := filepath.Join(projectRoot, cleanRel)
-	if candidateParent == projectRoot || strings.HasPrefix(candidateParent, projectRoot+string(filepath.Separator)) {
-		if info, err := os.Stat(candidateParent); err == nil && !info.IsDir() {
-			return candidateParent, true
-		}
-	}
-
-	return "", false
-}
-
-func Serve(w http.ResponseWriter, r *http.Request, filePath string) error {
-	encoding := pickEncoding(r.Header.Get("Accept-Encoding"))
-	contentType := contentTypeFor(filePath)
-	cacheControl := cacheControlFor(filePath)
-
-	if encoding != "" {
-		ext := ".gz"
-		if encoding == "br" {
-			ext = ".br"
-		}
-		if f, err := os.Open(filePath + ext); err == nil {
-			defer f.Close()
-			w.Header().Set("Content-Type", contentType)
-			w.Header().Set("Cache-Control", cacheControl)
-			w.Header().Set("Content-Encoding", encoding)
-			w.Header().Set("Vary", "Accept-Encoding")
-			w.WriteHeader(http.StatusOK)
-			_, err := io.Copy(w, f)
-			return err
-		}
-	}
-
-	f, err := os.Open(filePath)
-	if err != nil {
-		return err
-	}
-	defer f.Close()
-
-	w.Header().Set("Content-Type", contentType)
-	w.Header().Set("Cache-Control", cacheControl)
-
-	if encoding == "gzip" {
-		w.Header().Set("Content-Encoding", "gzip")
-		w.Header().Set("Vary", "Accept-Encoding")
-		w.WriteHeader(http.StatusOK)
-		gz := gzip.NewWriter(w)
-		defer gz.Close()
-		_, err := io.Copy(gz, f)
-		return err
-	}
-
-	w.WriteHeader(http.StatusOK)
-	_, err = io.Copy(w, f)
-	return err
-}

package/framework/node_modules/.vite/vitest/da39a3ee5e6b4b0d3255bfef95601890afd80709/results.json

@@ -1 +0,0 @@
-{"version":"4.1.4","results":[[":__tests__/component-full.test.js",{"duration":129.91820000000007,"failed":false}],[":__tests__/router-dynamic.test.js",{"duration":234.65790000000015,"failed":false}],[":__tests__/core.test.js",{"duration":791.7873999999993,"failed":false}],[":__tests__/compiler.test.js",{"duration":260.6435999999994,"failed":false}],[":__tests__/signal-full.test.js",{"duration":82.13780000000042,"failed":false}],[":__tests__/actions.test.js",{"duration":110.89980000000014,"failed":false}],[":__tests__/integration.test.js",{"duration":426.259399999999,"failed":false}],[":__tests__/memory-leaks.test.js",{"duration":300.5116999999991,"failed":false}],[":__tests__/store.test.js",{"duration":94.34749999999985,"failed":false}],[":__tests__/signal.test.js",{"duration":55.624000000000706,"failed":false}],[":__tests__/hydration.test.js",{"duration":49.02929999999924,"failed":false}],[":__tests__/resource.test.js",{"duration":342.90250000000015,"failed":false}],[":__tests__/benchmark.test.js",{"duration":101.09839999999986,"failed":false}],[":__tests__/file-router.test.js",{"duration":56.23449999999957,"failed":false}],[":__tests__/async-context.test.js",{"duration":41.451100000000224,"failed":false}],[":__tests__/router-query.test.js",{"duration":63.17019999999957,"failed":false}],[":__tests__/DI_v2.test.js",{"duration":19.370700000000397,"failed":false}],[":__tests__/DI.test.js",{"duration":120.94930000000022,"failed":false}],[":__tests__/final.test.js",{"duration":73.53499999999985,"failed":false}],[":__tests__/final-phase1.test.js",{"duration":12.186300000000301,"failed":false}],[":__tests__/pipeline.test.js",{"duration":164.90560000000005,"failed":false}],[":__tests__/dispatcher.test.js",{"duration":68.17020000000048,"failed":false}]]}