@saolabs/client 1.5.2 → 1.7.1

package/src/core/services/HttpService.ts

@@ -15,6 +15,9 @@
  *   });
  */
 
+import { app } from '../helpers/app.js';
+import { AuthService } from './AuthService.js';
+
 // ─── Types ──────────────────────────────────────────────────────
 
 export interface HttpRequestConfig extends RequestInit {
@@ -171,10 +174,28 @@ export class HttpService {
             }
             if (!group) this.pending.set(requestKey, group = new Set());
             group.add(controller);
+            const auth = app.has('Auth') ? app<AuthService>('Auth') : null;
+            const authRevision = auth?.revision;
+            // Read at send time: session login/logout rotates Laravel's CSRF token.
+            if (typeof window !== 'undefined' && urlObj.origin === window.location.origin
+                && !['GET', 'HEAD', 'OPTIONS'].includes(config.method!)) {
+                const headers = config.headers ??= {};
+                const explicit = Object.keys(headers).some(key => ['x-csrf-token', 'x-xsrf-token'].includes(key.toLowerCase()));
+                const token = auth?.client.csrfToken ?? document.querySelector<HTMLMetaElement>('meta[name="csrf-token"]')?.content;
+                if (!explicit && token) headers['X-CSRF-TOKEN'] = token;
+            }
             const raw = await fetch(fullUrl, config);
             const responseData = await raw.json().catch(() => ({}));
             controller.signal.throwIfAborted();
 
+            // Only our own server may synchronize auth; an older request cannot undo a newer login/logout.
+            if (auth && !auth.isTransitioning && auth.revision === authRevision && typeof window !== 'undefined'
+                && urlObj.origin === window.location.origin
+                && (!raw.url || new URL(raw.url).origin === window.location.origin)
+                && AuthService.isSnapshot(responseData?.auth)) {
+                auth.sync(responseData.auth);
+            }
+
             const viewContext = responseData?.viewContext;
             const currentContext = typeof window !== 'undefined'
                 ? (window as any).APP_CONFIGS?.view?.systemData?.__context__

package/src/core/services/ReactiveDependency.ts

@@ -0,0 +1,46 @@
+/** A service can participate in computed evaluation without exposing its storage. */
+export interface ReactiveDependency {
+    subscribe(callback: () => void): () => void;
+}
+
+let collecting: Set<ReactiveDependency> | null = null;
+
+export function trackDependency(source: ReactiveDependency): void {
+    collecting?.add(source);
+}
+
+/** Reconciles subscriptions after each synchronous evaluation, including branch changes. */
+export class DependencyTracker {
+    private subscriptions = new Map<ReactiveDependency, () => void>();
+    private destroyed = false;
+
+    constructor(private readonly invalidate: () => void) {}
+
+    evaluate<T>(read: () => T): T {
+        const previous = collecting;
+        const sources = new Set<ReactiveDependency>();
+        collecting = sources;
+        try { return read(); }
+        finally {
+            collecting = previous;
+            if (!this.destroyed) {
+                for (const [source, off] of this.subscriptions) {
+                    if (!sources.has(source)) { off(); this.subscriptions.delete(source); }
+                }
+                for (const source of sources) {
+                    if (!this.subscriptions.has(source)) {
+                        this.subscriptions.set(source, source.subscribe(() => {
+                            if (!this.destroyed) this.invalidate();
+                        }));
+                    }
+                }
+            }
+        }
+    }
+
+    destroy(): void {
+        this.destroyed = true;
+        for (const off of this.subscriptions.values()) off();
+        this.subscriptions.clear();
+    }
+}

package/src/core/services/index.ts

@@ -5,6 +5,8 @@ export * from "./HeadService.js";
 export * from "./SectionManager.js";
 export * from "./LoggerService.js";
 export * from './HelperService.js';
+export * from './AuthService.js';
+export * from './AuthClient.js';
 export * from './HttpService.js';
 export * from './MarkerRegistry.js';
 export * from "./StoreService.js";

package/src/core/view/ViewController.ts

@@ -84,6 +84,8 @@ export class ViewController implements ViewControllerInterface {
     public superView: ViewControllerInterface | null = null;
     /** Path to layout (super) view — e.g. 'layouts.main' */
     public superViewPath: string | null = null;
+    /** Data last passed to the layout by `@extends` — re-applied when the page is restored from PageCache (render() does not run then). */
+    public superViewData: Record<string, any> | null = null;
     /** Whether this controller IS a layout */
     public isSuperView: boolean = false;
     /** For layouts: the original page view's controller (for block mounting) */
@@ -1497,6 +1499,7 @@ export class ViewController implements ViewControllerInterface {
 
     extendView(path: string, data: Record<string, any> = {}): ViewInterface | null {
         this.superViewPath = path;
+        this.superViewData = data;
         // Sync: render() trả superView ngay (xem ViewManager.resolveViewSync).
         const superView: ViewInterface = this.App.View?.resolveViewSync(path, data, true);
         if (superView) {

package/src/core/view/ViewManager.ts

@@ -390,6 +390,18 @@ export class ViewManager implements ViewManagerInterface {
         return this.hasView(name);
     }
 
+    /** Read compiler/builder metadata without invoking setup or importing a lazy chunk. */
+    getViewMiddleware(name: string): readonly string[] {
+        const key = this.resolveRegistryKey(name);
+        const factory = this.viewRegistry[key] ?? this.resolvedFactories.get(key);
+        const middleware = (factory as any)?.middleware;
+        if (middleware === undefined) return [];
+        if (!Array.isArray(middleware) || middleware.some(ref => typeof ref !== 'string')) {
+            throw new TypeError(`Invalid middleware metadata on view "${name}".`);
+        }
+        return [...middleware];
+    }
+
     /**
      * generateViewId — tạo unique ID cho mỗi view instance.
      *
@@ -1464,6 +1476,17 @@ export class ViewManager implements ViewManagerInterface {
             }
 
             this.blockManager.restorePageContent(pageView.__ctrl__.viewId, entry.outletContents);
+            // render() không chạy lại khi restore → extendView() không gọi: layout dùng
+            // chung còn giữ dữ liệu @extends của trang trước. Áp lại dữ liệu của trang này.
+            // Lưu ý: updateData chỉ GỘP — khoá trang không truyền vẫn giữ giá trị cũ
+            // (mặc định @vars nằm trong closure compiled), nên trang nên truyền tường minh.
+            for (const v of entry.views) {
+                const ctrl = v.__ctrl__ as any;
+                const superView = ctrl.superView;
+                if (superView && ctrl.superViewData && layoutChain.some(l => l.__ctrl__ === superView)) {
+                    superView.updateData?.(ctrl.superViewData);
+                }
+            }
             for (const v of entry.views) {
                 v.__ctrl__.resume();
             }

package/src/core/view/ViewState.ts

@@ -1,6 +1,9 @@
 import type { ViewControllerInterface } from "../contracts/ViewControllerInterface.js";
 import type { StateManagerInterface, ViewStateInterface, StateItem, StateListener } from "../contracts/ViewStateInterface.js";
 import devtools from "../devtools/hook.js";
+import { DependencyTracker } from '../services/ReactiveDependency.js';
+import { AuthService } from '../services/AuthService.js';
+import { app } from '../helpers/app.js';
 
 type MutationChannel = {
     notify: (() => void) | null;
@@ -188,8 +191,9 @@ export class StateManager implements StateManagerInterface {
         return this.useState(value, key)[1];
     }
 
-    private computedNodes = new Map<string, { deps: string[]; dirty: () => void }>();
+    private computedNodes = new Map<string, { deps: string[]; dirty: () => void; tracker: DependencyTracker }>();
     private computedDependents = new Map<string | number, Set<string>>();
+    private authUnsubscribe: (() => void) | null = null;
 
     /** Invalidate the dependency graph synchronously; evaluation remains lazy. */
     private invalidateComputed(key: string | number, notify = true): void {
@@ -234,6 +238,7 @@ export class StateManager implements StateManagerInterface {
         if (deps.some(dep => reaches(dep))) throw new Error(`[ViewState] Computed dependency cycle: ${key}`);
         const existing = this.states[key] as any;
         if (existing && !existing.__computed__) throw new Error(`[ViewState] State already exists: ${key}`);
+        this.computedNodes.get(key)?.tracker.destroy();
         for (const dep of this.computedNodes.get(key)?.deps ?? []) {
             const dependents = this.computedDependents.get(dep);
             dependents?.delete(key);
@@ -242,6 +247,10 @@ export class StateManager implements StateManagerInterface {
         let cache: T;
         let dirty = true;
         let evaluating = false;
+        const tracker = new DependencyTracker(() => {
+            dirty = true;
+            this.enqueueChange(key);
+        });
         const slot: any = {
             key,
             __computed__: true,
@@ -252,7 +261,7 @@ export class StateManager implements StateManagerInterface {
                 if (dirty) {
                     if (evaluating) throw new Error(`[ViewState] Recursive computed read: ${key}`);
                     evaluating = true;
-                    try { cache = fn(); dirty = false; }
+                    try { cache = tracker.evaluate(fn); dirty = false; }
                     finally { evaluating = false; }
                 }
                 return cache;
@@ -262,7 +271,7 @@ export class StateManager implements StateManagerInterface {
         });
         this.states[key] = slot;
         this.setters[key] = slot.setValue;
-        this.computedNodes.set(key, { deps: [...new Set(deps)], dirty: () => { dirty = true; } });
+        this.computedNodes.set(key, { deps: [...new Set(deps)], dirty: () => { dirty = true; }, tracker });
         for (const dep of deps) {
             if (!this.computedDependents.has(dep)) this.computedDependents.set(dep, new Set());
             this.computedDependents.get(dep)!.add(key);
@@ -367,6 +376,21 @@ export class StateManager implements StateManagerInterface {
             if (!records) this.subscriptions.set(k, records = new Set());
             records.add(record);
         }
+        if (keys.has('@auth') && !this.authUnsubscribe) {
+            const application = this.controller?.App ?? app();
+            if (!application.has('Auth')) {
+                application.instance('Auth', AuthService.fromSnapshot(application.shared('auth')));
+            }
+            this.authUnsubscribe = (application.get('Auth') as AuthService).subscribe(() => this.enqueueChange('@auth'));
+        }
+        // Hydration may claim an SSR text node without evaluating its factory.
+        // Observed computed values still need their service dependencies connected.
+        try {
+            for (const k of keys) if (this.computedNodes.has(k)) this.getStateByKey(k);
+        } catch (error) {
+            this.removeSubscription(record);
+            throw error;
+        }
         return () => this.removeSubscription(record);
     }
 
@@ -378,6 +402,10 @@ export class StateManager implements StateManagerInterface {
             records?.delete(record);
             if (records?.size === 0) this.subscriptions.delete(k);
         }
+        if (!this.subscriptions.has('@auth')) {
+            this.authUnsubscribe?.();
+            this.authUnsubscribe = null;
+        }
     }
 
     unsubscribe(
@@ -1079,6 +1107,9 @@ export class StateManager implements StateManagerInterface {
             cancelAnimationFrame(this.flushRAF);
             this.flushRAF = null;
         }
+        this.authUnsubscribe?.();
+        this.authUnsubscribe = null;
+        for (const node of this.computedNodes.values()) node.tracker.destroy();
         this.computedNodes.clear();
         this.computedDependents.clear();
         this.versions.clear();