ezfw-core 1.0.79 → 1.0.82

package/components/EzBaseComponent.ts

@@ -1094,6 +1094,11 @@ export class EzBaseComponent {
     }
 
     destroy(): void {
+        // Call controller onDestroy if exists
+        if (this.controller && typeof (this.controller as EzController & { onDestroy?: () => void }).onDestroy === 'function') {
+            (this.controller as EzController & { onDestroy?: () => void }).onDestroy!();
+        }
+
         // Destroy children first
         if (this._children) {
             for (const child of this._children) {

package/core/renderer.ts

@@ -421,30 +421,35 @@ export class EzRenderer {
         }
     }
 
-    async executeOnInit(config: ComponentConfig, controllerName: string | null): Promise<void> {
-        let controller = this.ez._controllers[controllerName || ''];
+    async executeOnInit(instance: EzBaseComponent | null, config: ComponentConfig): Promise<void> {
+        // Prefer instance's config and controller when available
+        const effectiveConfig = (instance?.config || config) as ComponentConfig;
 
-        if (!controller && config.controller) {
-            const ctrlName = typeof config.controller === 'string'
-                ? config.controller
+        let controller: ControllerInstance | null = null;
+
+        if (instance?.controller) {
+            controller = instance.controller as unknown as ControllerInstance;
+        } else if (effectiveConfig.controller) {
+            const ctrlName = typeof effectiveConfig.controller === 'string'
+                ? effectiveConfig.controller
                 : null;
             if (ctrlName) {
-                controller = this.ez._controllers[ctrlName]
-                    || this.ez._controllers[`${ctrlName}Controller`];
-            } else if (typeof config.controller === 'object') {
-                controller = config.controller as ControllerInstance;
+                controller = this.ez._controllers[ctrlName] ||
+                    this.ez._controllers[`${ctrlName}Controller`];
+            } else if (typeof effectiveConfig.controller === 'object') {
+                controller = effectiveConfig.controller as ControllerInstance;
             }
         }
 
         if (!controller) return;
 
-        let fn: unknown = config.init;
+        let fn: unknown = effectiveConfig.init;
         if (typeof fn === 'string') {
             fn = controller[fn];
         }
 
         if (typeof fn === 'function') {
-            await fn.call(controller, config);
+            await fn.call(controller, instance);
         }
     }
 
@@ -1051,7 +1056,7 @@ export class EzRenderer {
 
         if (config.init && config.skipInit !== true) {
             queueMicrotask(() => {
-                this.executeOnInit(config, controllerName)
+                this.executeOnInit(instance || null, config)
                     .catch(err => this.ez.handleFrameworkError(err));
             });
         }

package/islands/StaticHtmlRenderer.d.ts

@@ -11,6 +11,7 @@ export interface RenderContext {
     islands: IslandData[];
     props?: Record<string, unknown>;
     serverData?: Record<string, unknown>;
+    insideIsland?: boolean;
 }
 export interface IslandData {
     id: string;
@@ -108,7 +109,8 @@ export declare class StaticHtmlRenderer {
      */
     private serializableProps;
     /**
-     * Reset island counter (for testing)
+     * Reset island counter and clear analyzer cache
+     * Called before each SSR render to ensure fresh analysis
      */
     resetIslandCounter(): void;
 }

package/islands/StaticHtmlRenderer.js

@@ -36,7 +36,6 @@ let islandIdCounter = 0;
  * Main static renderer class
  */
 export class StaticHtmlRenderer {
-    analyzer;
     constructor() {
         this.analyzer = analyzer;
     }
@@ -76,6 +75,11 @@ export class StaticHtmlRenderer {
             // Try to render as native HTML element
             return this.renderNativeElement(name, props, ctx);
         }
+        // If we're inside an island or template-based component, render children as static
+        // (they will be re-rendered when the parent hydrates or when SPA takes over)
+        if (ctx.insideIsland || ctx.insideTemplate) {
+            return this.renderStaticComponent(name, definition, props, ctx);
+        }
         // Analyze the component
         const analysis = this.analyzer.analyze(name, definition);
         if (analysis.type === 'island') {
@@ -94,6 +98,10 @@ export class StaticHtmlRenderer {
             ctx.styles.add(definition.css);
         }
         let config;
+        // If this component has a template, mark context so children render as static
+        // Template-based components are re-rendered by SPA, so their children don't need island markers
+        const hasTemplate = !!definition.template;
+        const childCtx = hasTemplate ? { ...ctx, insideTemplate: true } : ctx;
         // Get component config from template or items
         if (definition.template) {
             // Get controller state for SSR
@@ -138,8 +146,8 @@ export class StaticHtmlRenderer {
                 config[key] = definition[key];
             }
         }
-        // Render the config tree
-        return this.renderConfig(config, ctx);
+        // Render the config tree using childCtx (which has insideTemplate=true if this has a template)
+        return this.renderConfig(config, childCtx);
     }
     /**
      * Render an island as a placeholder with hydration data
@@ -158,7 +166,10 @@ export class StaticHtmlRenderer {
         };
         ctx.islands.push(islandData);
         // Render the full static content (for SEO)
-        const staticContent = await this.renderStaticComponent(name, definition, props, ctx);
+        // Mark that we're inside an island so child components don't become islands
+        // (they will be re-rendered when this island hydrates on the client)
+        const islandCtx = { ...ctx, insideIsland: true };
+        const staticContent = await this.renderStaticComponent(name, definition, props, islandCtx);
         // Wrap in island container with data attributes for hydration
         const propsJson = this.escapeAttr(JSON.stringify(islandData.props));
         return `<div data-ez-island="${name}" data-ez-island-id="${islandId}" data-ez-props="${propsJson}">${staticContent}</div>`;
@@ -447,10 +458,12 @@ hydrateIslands(window.__EZ_ISLANDS__);
         return result;
     }
     /**
-     * Reset island counter (for testing)
+     * Reset island counter and clear analyzer cache
+     * Called before each SSR render to ensure fresh analysis
      */
     resetIslandCounter() {
         islandIdCounter = 0;
+        this.analyzer.clearCache();
     }
 }
 // Export singleton

package/islands/StaticHtmlRenderer.ts

@@ -19,6 +19,12 @@ export interface RenderContext {
     props?: Record<string, unknown>;
     // Server-side data loaded via load()
     serverData?: Record<string, unknown>;
+    // True when rendering inside an island - children should not be islands
+    // (they will be re-rendered when the parent island hydrates)
+    insideIsland?: boolean;
+    // True when rendering inside a template-based component
+    // Template components are re-rendered by SPA, so children don't need islands
+    insideTemplate?: boolean;
 }
 
 export interface IslandData {
@@ -150,6 +156,12 @@ export class StaticHtmlRenderer {
             return this.renderNativeElement(name, props as ComponentConfig, ctx);
         }
 
+        // If we're inside an island or template-based component, render children as static
+        // (they will be re-rendered when the parent hydrates or when SPA takes over)
+        if (ctx.insideIsland || ctx.insideTemplate) {
+            return this.renderStaticComponent(name, definition, props, ctx);
+        }
+
         // Analyze the component
         const analysis = this.analyzer.analyze(name, definition);
 
@@ -178,6 +190,11 @@ export class StaticHtmlRenderer {
 
         let config: ComponentConfig;
 
+        // If this component has a template, mark context so children render as static
+        // Template-based components are re-rendered by SPA, so their children don't need island markers
+        const hasTemplate = !!definition.template;
+        const childCtx = hasTemplate ? { ...ctx, insideTemplate: true } : ctx;
+
         // Get component config from template or items
         if (definition.template) {
             // Get controller state for SSR
@@ -224,8 +241,8 @@ export class StaticHtmlRenderer {
             }
         }
 
-        // Render the config tree
-        return this.renderConfig(config, ctx);
+        // Render the config tree using childCtx (which has insideTemplate=true if this has a template)
+        return this.renderConfig(config, childCtx);
     }
 
     /**
@@ -252,7 +269,10 @@ export class StaticHtmlRenderer {
         ctx.islands.push(islandData);
 
         // Render the full static content (for SEO)
-        const staticContent = await this.renderStaticComponent(name, definition, props, ctx);
+        // Mark that we're inside an island so child components don't become islands
+        // (they will be re-rendered when this island hydrates on the client)
+        const islandCtx = { ...ctx, insideIsland: true };
+        const staticContent = await this.renderStaticComponent(name, definition, props, islandCtx);
 
         // Wrap in island container with data attributes for hydration
         const propsJson = this.escapeAttr(JSON.stringify(islandData.props));
@@ -554,10 +574,12 @@ hydrateIslands(window.__EZ_ISLANDS__);
     }
 
     /**
-     * Reset island counter (for testing)
+     * Reset island counter and clear analyzer cache
+     * Called before each SSR render to ensure fresh analysis
      */
     resetIslandCounter(): void {
         islandIdCounter = 0;
+        this.analyzer.clearCache();
     }
 }
 

package/islands/analyzer.d.ts

@@ -47,7 +47,8 @@ export interface ComponentDefinition {
 export declare class ComponentAnalyzer {
     private cache;
     /**
-     * Analyze a component definition and determine its type
+     * Analyze a component definition and determine its type.
+     * Cache is cleared by StaticHtmlRenderer.resetIslandCounter() before each SSR render.
      */
     analyze(name: string, definition: ComponentDefinition): AnalysisResult;
     /**

package/islands/analyzer.js

@@ -58,9 +58,12 @@ const BROWSER_API_PATTERNS = [
  * Main analyzer class
  */
 export class ComponentAnalyzer {
-    cache = new Map();
+    constructor() {
+        this.cache = new Map();
+    }
     /**
-     * Analyze a component definition and determine its type
+     * Analyze a component definition and determine its type.
+     * Cache is cleared by StaticHtmlRenderer.resetIslandCounter() before each SSR render.
      */
     analyze(name, definition) {
         // Check cache first

package/islands/analyzer.ts

@@ -95,7 +95,8 @@ export class ComponentAnalyzer {
     private cache: Map<string, AnalysisResult> = new Map();
 
     /**
-     * Analyze a component definition and determine its type
+     * Analyze a component definition and determine its type.
+     * Cache is cleared by StaticHtmlRenderer.resetIslandCounter() before each SSR render.
      */
     analyze(name: string, definition: ComponentDefinition): AnalysisResult {
         // Check cache first

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ezfw-core",
-  "version": "1.0.79",
+  "version": "1.0.82",
   "description": "Ez Framework - A declarative component framework for building modern web applications",
   "type": "module",
   "main": "./core/ez.ts",