fusee-framework 2.7.0 → 2.7.1

package/framework/engine-go/hydration.go

@@ -1,43 +0,0 @@
-package engine
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-)
-
-type Payload struct {
-	Resources map[string]map[string]any `json:"resources"`
-	Signals   map[string][]any          `json:"signals"`
-}
-
-func RenderDehydrationScript(resources map[string]map[string]any, signals map[string][]any) (string, error) {
-	if resources == nil {
-		resources = map[string]map[string]any{}
-	}
-	if signals == nil {
-		signals = map[string][]any{}
-	}
-
-	payload := Payload{Resources: resources, Signals: signals}
-	raw, err := json.Marshal(payload)
-	if err != nil {
-		return "", fmt.Errorf("hydration: failed to serialize state: %w", err)
-	}
-
-	return fmt.Sprintf(`<script id="__FUSEE_DATA__">window.__FUSEE_STATE__ = %s;</script>`, raw), nil
-}
-
-func BuildFromContext(ctx context.Context) (string, error) {
-	var resources map[string]map[string]any
-	if rc := From(ctx); rc != nil {
-		resources = rc.ResourceCache
-	}
-
-	var signals map[string][]any
-	if reg := RegistryFrom(ctx); reg != nil {
-		signals = reg.Snapshot()
-	}
-
-	return RenderDehydrationScript(resources, signals)
-}

package/framework/engine-go/load-helpers.go

@@ -1,29 +0,0 @@
-package engine
-
-import "fmt"
-
-type RouteRedirect struct {
-	Status   int
-	Location string
-}
-
-func (e *RouteRedirect) Error() string {
-	return fmt.Sprintf("redirect(%d) to %s", e.Status, e.Location)
-}
-
-type RouteHTTPError struct {
-	Status  int
-	Message string
-}
-
-func (e *RouteHTTPError) Error() string {
-	return e.Message
-}
-
-func Redirect(status int, location string) error {
-	return &RouteRedirect{Status: status, Location: location}
-}
-
-func HTTPError(status int, message string) error {
-	return &RouteHTTPError{Status: status, Message: message}
-}

package/framework/engine-go/manifest.go

@@ -1,41 +0,0 @@
-package engine
-
-import (
-	"encoding/json"
-	"fmt"
-	"os"
-
-	"fusee/rustast"
-)
-
-type ManifestRoute struct {
-	Pattern  string        `json:"pattern"`
-	FilePath string        `json:"filePath"`
-	Title    string        `json:"title"`
-	AST      *rustast.Node `json:"ast"`
-}
-
-type Manifest struct {
-	Version  string           `json:"version"`
-	Routes   []*ManifestRoute `json:"routes"`
-	Elements []*Element       `json:"elements"`
-}
-
-// ElementRegistry returns the manifest's custom elements, ready for RenderWithElements.
-func (m *Manifest) ElementRegistry() ElementRegistry {
-	return NewElementRegistry(m.Elements)
-}
-
-func LoadManifest(manifestPath string) (*Manifest, error) {
-	data, err := os.ReadFile(manifestPath)
-	if err != nil {
-		return nil, fmt.Errorf("failed to read manifest: %w", err)
-	}
-
-	var manifest Manifest
-	if err := json.Unmarshal(data, &manifest); err != nil {
-		return nil, fmt.Errorf("failed to unmarshal manifest: %w", err)
-	}
-
-	return &manifest, nil
-}

package/framework/engine-go/reactive.go

@@ -1,123 +0,0 @@
-package engine
-
-import (
-	"context"
-	"encoding/json"
-	"sync"
-)
-
-type registryKey struct{}
-type frameKey struct{}
-type frame struct {
-	scopeID string
-	index   int
-}
-type Registry struct {
-	mu   sync.Mutex
-	data map[string][]any
-}
-
-func NewRegistry() *Registry {
-	return &Registry{data: make(map[string][]any)}
-}
-
-func WithRegistry(ctx context.Context, reg *Registry) context.Context {
-	return context.WithValue(ctx, registryKey{}, reg)
-}
-
-func registryFrom(ctx context.Context) *Registry {
-	reg, _ := ctx.Value(registryKey{}).(*Registry)
-	return reg
-}
-
-func RegistryFrom(ctx context.Context) *Registry {
-	return registryFrom(ctx)
-}
-
-func (r *Registry) Snapshot() map[string][]any {
-	r.mu.Lock()
-	defer r.mu.Unlock()
-	out := make(map[string][]any, len(r.data))
-	for k, v := range r.data {
-		cp := make([]any, len(v))
-		copy(cp, v)
-		out[k] = cp
-	}
-	return out
-}
-
-func (r *Registry) Load(snapshot map[string][]any) {
-	r.mu.Lock()
-	defer r.mu.Unlock()
-	for k, v := range snapshot {
-		r.data[k] = v
-	}
-}
-
-func WithScope(ctx context.Context, scopeID string, fn func(ctx context.Context)) {
-	f := &frame{scopeID: scopeID, index: 0}
-	fn(context.WithValue(ctx, frameKey{}, f))
-}
-
-func currentFrame(ctx context.Context) *frame {
-	f, _ := ctx.Value(frameKey{}).(*frame)
-	return f
-}
-
-type Signal[T any] struct {
-	mu    sync.Mutex
-	value T
-}
-
-func (s *Signal[T]) Get() T {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	return s.value
-}
-
-func (s *Signal[T]) Set(v T) {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	s.value = v
-}
-
-func NewSignal[T any](ctx context.Context, initial T) *Signal[T] {
-	f := currentFrame(ctx)
-	if f == nil {
-		return &Signal[T]{value: initial}
-	}
-	reg := registryFrom(ctx)
-	if reg == nil {
-		return &Signal[T]{value: initial}
-	}
-
-	reg.mu.Lock()
-	defer reg.mu.Unlock()
-
-	idx := f.index
-	f.index++
-
-	list := reg.data[f.scopeID]
-	if idx < len(list) && list[idx] != nil {
-		var hydrated T
-		if err := reDecode(list[idx], &hydrated); err == nil {
-			return &Signal[T]{value: hydrated}
-		}
-	}
-
-	for len(list) <= idx {
-		list = append(list, nil)
-	}
-	list[idx] = initial
-	reg.data[f.scopeID] = list
-
-	return &Signal[T]{value: initial}
-}
-
-func reDecode(v any, out any) error {
-	b, err := json.Marshal(v)
-	if err != nil {
-		return err
-	}
-	return json.Unmarshal(b, out)
-}